Coverage Report

Created: 2025-06-10 07:15

/src/ghostpdl/base/gsroprun1.h
Line
Count
Source (jump to first uncovered line)
1
/* Copyright (C) 2001-2023 Artifex Software, Inc.
2
   All Rights Reserved.
3
4
   This software is provided AS-IS with no warranty, either express or
5
   implied.
6
7
   This software is distributed under license and may not be copied,
8
   modified or distributed except as expressly authorized under the terms
9
   of the license contained in the file LICENSE in this distribution.
10
11
   Refer to licensing information at http://www.artifex.com or contact
12
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
13
   CA 94129, USA, for further information.
14
*/
15
16
17
/* This file is repeatedly included by gsroprun.c to 'autogenerate' many
18
 * different versions of roprun code. DO NOT USE THIS FILE EXCEPT FROM
19
 * gsroprun.c.
20
 */
21
22
/* Set the following defines as appropriate on entry:
23
 *   TEMPLATE_NAME (Compulsory)  The name of the function to generate
24
 *   SPECIFIC_ROP  (Optional)    If set, the function will base its decision
25
 *                               about whether to provide S and T upon
26
 *                               this value.
27
 *   SPECIFIC_CODE (Optional)    If set, this should expand out to code to
28
 *                               perform the rop. Will be invoked as:
29
 *                               SPECIFIC_ROP(OUT,D,S,T)
30
 *   S_CONST       (Optional)    If set, S will be taken to be constant, else
31
 *                               S will be read from a pointer.
32
 *   T_CONST       (Optional)    If set, T will be taken to be constant, else
33
 *                               T will be read from a pointer.
34
 */
35
36
#if defined(TEMPLATE_NAME)
37
38
#ifdef SPECIFIC_ROP
39
#if rop3_uses_S(SPECIFIC_ROP)
40
#define S_USED
41
#endif
42
#if rop3_uses_T(SPECIFIC_ROP)
43
#define T_USED
44
#endif
45
#else /* !SPECIFIC_ROP */
46
#define S_USED
47
#define T_USED
48
#endif /* SPECIFIC_ROP */
49
50
/* We work in 'chunks' here; for bigendian machines, we can safely use
51
 * chunks of 'int' size. For little endian machines where we have a cheap
52
 * endian swap, we can do likewise. For others, we'll work at the byte
53
 * level. */
54
#if !ARCH_IS_BIG_ENDIAN && !defined(ENDIAN_SWAP_INT)
55
#define CHUNKSIZE 8
56
#define CHUNK byte
57
#define CHUNKONES 255
58
59
#define ADJUST_TO_CHUNK(d,dpos) do {} while (0)
60
61
#else /* ARCH_IS_BIG_ENDIAN || defined(ENDIAN_SWAP_INT) */
62
#if ARCH_LOG2_SIZEOF_INT == 2
63
11.7M
#define CHUNKSIZE 32
64
4.34M
#define CHUNK unsigned int
65
2.16M
#define CHUNKONES 0xFFFFFFFFU
66
67
#if ARCH_SIZEOF_PTR == (1<<ARCH_LOG2_SIZEOF_INT)
68
#define ROP_PTRDIFF_T int
69
#else
70
#define ROP_PTRDIFF_T int64_t
71
#endif
72
#define ADJUST_TO_CHUNK(d, dpos)                      \
73
2.16M
    do { int offset = ((ROP_PTRDIFF_T)d) & ((CHUNKSIZE>>3)-1);  \
74
2.16M
         d = (CHUNK *)(void *)(((byte *)(void *)d)-offset);   \
75
2.16M
         dpos += offset<<3;                           \
76
2.16M
     } while (0)
77
#else
78
/* FIXME: Write more code in here when we find an example. */
79
#endif
80
#endif /* ARCH_IS_BIG_ENDIAN || defined(ENDIAN_SWAP_INT) */
81
82
/* We define an 'RE' macro that reverses the endianness of a chunk, if we
83
 * need it, and does nothing otherwise. */
84
#if !ARCH_IS_BIG_ENDIAN && defined(ENDIAN_SWAP_INT) && (CHUNKSIZE != 8)
85
8.63M
#define RE(I) ((CHUNK)ENDIAN_SWAP_INT(I))
86
#else /* ARCH_IS_BIG_ENDIAN || !defined(ENDIAN_SWAP_INT) || (CHUNKSIZE == 8) */
87
#define RE(I) (I)
88
#endif /* ARCH_IS_BIG_ENDIAN || !defined(ENDIAN_SWAP_INT) || (CHUNKSIZE == 8) */
89
90
/* In some cases we will need to fetch values from a pointer, and 'skew'
91
 * them. We need 2 variants of this macro. One that is 'SAFE' to use when
92
 * SKEW might be 0, and one that can be faster, because we know that SKEW
93
 * is non zero. */
94
#define SKEW_FETCH(S,s,SKEW) \
95
781k
    do { S = RE((RE(s[0])<<SKEW) | (RE(s[1])>>(CHUNKSIZE-SKEW))); s++; } while (0)
96
#define SAFE_SKEW_FETCH(S,s,SKEW,L,R)                                    \
97
2.15M
    do { S = RE(((L) ? 0 : (RE(s[0])<<SKEW)) | ((R) ? 0 : (RE(s[1])>>(CHUNKSIZE-SKEW)))); s++; } while (0)
98
99
#if defined(S_USED) && !defined(S_CONST)
100
#define S_SKEW
101
781k
#define FETCH_S           SKEW_FETCH(S,s,s_skew)
102
2.15M
#define SAFE_FETCH_S(L,R) SAFE_SKEW_FETCH(S,s,s_skew,L,R)
103
#else /* !defined(S_USED) || defined(S_CONST) */
104
#define FETCH_S
105
#define SAFE_FETCH_S(L,R)
106
#endif /* !defined(S_USED) || defined(S_CONST) */
107
108
#if defined(T_USED) && !defined(T_CONST)
109
#define T_SKEW
110
0
#define FETCH_T           SKEW_FETCH(T,t,t_skew)
111
0
#define SAFE_FETCH_T(L,R) SAFE_SKEW_FETCH(T,t,t_skew,L,R)
112
#else /* !defined(T_USED) || defined(T_CONST) */
113
#define FETCH_T
114
#define SAFE_FETCH_T(L,R)
115
#endif /* !defined(T_USED) || defined(T_CONST) */
116
117
static void TEMPLATE_NAME(rop_run_op *op, byte *d_, int len)
118
1.08M
{
119
#ifndef SPECIFIC_CODE
120
    rop_proc     proc = rop_proc_table[op->rop];
121
180k
#define SPECIFIC_CODE(OUT_, D_,S_,T_) OUT_ = proc(D_,S_,T_)
122
#endif /* !defined(SPECIFIC_CODE) */
123
1.08M
    CHUNK        lmask, rmask;
124
#ifdef S_USED
125
#ifdef S_CONST
126
0
    CHUNK        S = (CHUNK)op->s.c;
127
#else /* !defined(S_CONST) */
128
    const CHUNK *s = (CHUNK *)(void *)op->s.b.ptr;
129
1.08M
    CHUNK        S;
130
    int          s_skew;
131
#endif /* !defined(S_CONST) */
132
#else /* !defined(S_USED) */
133
#define S 0
134
#undef S_CONST
135
#endif /* !defined(S_USED) */
136
#ifdef T_USED
137
#ifdef T_CONST
138
7.63k
    CHUNK        T = (CHUNK)op->t.c;
139
#else /* !defined(T_CONST) */
140
    const CHUNK *t = (CHUNK *)(void *)op->t.b.ptr;
141
0
    CHUNK        T;
142
    int          t_skew;
143
#endif /* !defined(T_CONST) */
144
#else /* !defined(T_USED) */
145
#define T 0
146
#undef T_CONST
147
#endif /* !defined(T_USED) */
148
#if defined(S_SKEW) || defined(T_SKEW)
149
    int skewflags = 0;
150
#endif
151
1.08M
    CHUNK        D;
152
1.08M
    int          dpos = op->dpos;
153
1.08M
    CHUNK       *d = (CHUNK *)(void *)d_;
154
155
    /* Align d to CHUNKSIZE */
156
1.08M
    ADJUST_TO_CHUNK(d,dpos);
157
158
    /* On entry len = length in 'depth' chunks. Change it to be the length
159
     * in bits, and add on the number of bits we skip at the start of the
160
     * run. */
161
1.08M
    len    = len * op->depth + dpos;
162
163
    /* lmask = the set of bits to alter in the output bitmap on the left
164
     * hand edge of the run. rmask = the set of bits NOT to alter in the
165
     * output bitmap on the right hand edge of the run. */
166
1.08M
    lmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & dpos)));
167
1.08M
    rmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & len)));
168
1.08M
    if (rmask == CHUNKONES) rmask = 0;
169
170
#if defined(S_CONST) || defined(T_CONST)
171
    /* S and T should be supplied as 'depth' bits. Duplicate them up to be
172
     * byte size (if they are supplied byte sized, that's fine too). */
173
7.63k
    if (op->depth & 1) {
174
#ifdef S_CONST
175
        S |= S<<1;
176
#endif /* !defined(S_CONST) */
177
7.63k
#ifdef T_CONST
178
7.63k
        T |= T<<1;
179
7.63k
#endif /* !defined(T_CONST) */
180
7.63k
    }
181
7.63k
    if (op->depth & 3) {
182
#ifdef S_CONST
183
        S |= S<<2;
184
#endif /* !defined(S_CONST) */
185
7.63k
#ifdef T_CONST
186
7.63k
        T |= T<<2;
187
7.63k
#endif /* !defined(T_CONST) */
188
7.63k
    }
189
7.63k
    if (op->depth & 7) {
190
#ifdef S_CONST
191
        S |= S<<4;
192
#endif /* !defined(S_CONST) */
193
7.63k
#ifdef T_CONST
194
7.63k
        T |= T<<4;
195
7.63k
#endif /* !defined(T_CONST) */
196
7.63k
    }
197
#if CHUNKSIZE > 8
198
7.63k
    if (op->depth & 15) {
199
#ifdef S_CONST
200
        S |= S<<8;
201
#endif /* !defined(S_CONST) */
202
7.63k
#ifdef T_CONST
203
7.63k
        T |= T<<8;
204
7.63k
#endif /* !defined(T_CONST) */
205
7.63k
    }
206
#endif /* CHUNKSIZE > 8 */
207
#if CHUNKSIZE > 16
208
7.63k
    if (op->depth & 31) {
209
#ifdef S_CONST
210
        S |= S<<16;
211
#endif /* !defined(S_CONST) */
212
7.63k
#ifdef T_CONST
213
7.63k
        T |= T<<16;
214
7.63k
#endif /* !defined(T_CONST) */
215
7.63k
    }
216
#endif /* CHUNKSIZE > 16 */
217
#endif /* defined(S_CONST) || defined(T_CONST) */
218
219
    /* Note #1: This mirrors what the original code did, but I think it has
220
     * the risk of moving s and t back beyond officially allocated space. We
221
     * may be saved by the fact that all blocks have a word or two in front
222
     * of them due to the allocator. If we ever get valgrind properly marking
223
     * allocated blocks as readable etc, then this may throw some spurious
224
     * errors. RJW. */
225
#ifdef S_SKEW
226
    {
227
        int slen, slen2;
228
        int spos = op->s.b.pos;
229
1.08M
        ADJUST_TO_CHUNK(s, spos);
230
        s_skew = spos - dpos;
231
1.08M
        if (s_skew < 0) {
232
1.07M
            s_skew += CHUNKSIZE;
233
1.07M
            s--;
234
1.07M
            skewflags |= 1; /* Suppress reading off left edge */
235
1.07M
        }
236
        /* We are allowed to read all the data bits, so: len - dpos + tpos
237
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
238
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
239
         * This is larger, then suppress. */
240
1.08M
        slen  = (len + s_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
241
1.08M
        slen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
242
1.08M
        if ((s_skew == 0) || (slen < slen2)) {
243
84.8k
            skewflags |= 4; /* Suppress reading off the right edge */
244
84.8k
        }
245
    }
246
#endif /* !defined(S_SKEW) */
247
#ifdef T_SKEW
248
    {
249
        int tlen, tlen2;
250
        int tpos = op->t.b.pos;
251
0
        ADJUST_TO_CHUNK(t, tpos);
252
        t_skew = tpos - dpos;
253
0
        if (t_skew < 0) {
254
0
            t_skew += CHUNKSIZE;
255
0
            t--;
256
0
            skewflags |= 2; /* Suppress reading off left edge */
257
0
        }
258
        /* We are allowed to read all the data bits, so: len - dpos + tpos
259
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
260
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
261
         * This is larger, then suppress. */
262
0
        tlen  = (len + t_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
263
0
        tlen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
264
0
        if ((t_skew == 0) || (tlen < tlen2)) {
265
0
            skewflags |= 8; /* Suppress reading off the right edge */
266
0
        }
267
    }
268
#endif /* !defined(T_SKEW) */
269
270
1.08M
    len -= CHUNKSIZE; /* len = bytes to do - CHUNKSIZE */
271
    /* len <= 0 means 1 word or less to do */
272
1.08M
    if (len <= 0) {
273
        /* Short case - starts and ends in the same chunk */
274
0
        lmask &= ~rmask; /* Combined mask = bits to alter */
275
0
        SAFE_FETCH_S(skewflags & 1,skewflags & 4);
276
0
        SAFE_FETCH_T(skewflags & 2,skewflags & 8);
277
0
        SPECIFIC_CODE(D, *d, S, T);
278
0
        *d = (*d & ~lmask) | (D & lmask);
279
0
        return;
280
0
    }
281
1.08M
    if ((lmask != CHUNKONES)
282
#if defined(S_SKEW) || defined(T_SKEW)
283
10.6k
        || (skewflags & 3)
284
#endif
285
1.08M
        ) {
286
        /* Unaligned left hand case */
287
1.07M
        SAFE_FETCH_S(skewflags & 1,s_skew == 0);
288
1.07M
        SAFE_FETCH_T(skewflags & 2,t_skew == 0);
289
1.07M
        SPECIFIC_CODE(D, *d, S, T);
290
1.07M
        *d = (*d & ~lmask) | (D & lmask);
291
1.07M
        d++;
292
1.07M
        len -= CHUNKSIZE;
293
1.07M
    }
294
1.08M
    if (len > 0) {
295
        /* Simple middle case (complete destination chunks). */
296
#ifdef S_SKEW
297
388k
        if (s_skew == 0) {
298
#ifdef T_SKEW
299
0
            if (t_skew == 0) {
300
0
                do {
301
0
                    SPECIFIC_CODE(*d, *d, *s++, *t++);
302
0
                    d++;
303
0
                    len -= CHUNKSIZE;
304
0
                } while (len > 0);
305
0
            } else
306
0
#endif /* !defined(T_SKEW) */
307
0
            {
308
104k
                do {
309
104k
                    FETCH_T;
310
104k
                    SPECIFIC_CODE(*d, *d, *s++, T);
311
104k
                    d++;
312
104k
                    len -= CHUNKSIZE;
313
104k
                } while (len > 0);
314
0
            }
315
6.67k
        } else
316
382k
#endif /* !defined(S_SKEW) */
317
382k
        {
318
#ifdef T_SKEW
319
0
            if (t_skew == 0) {
320
0
                do {
321
0
                    FETCH_S;
322
0
                    SPECIFIC_CODE(*d, *d, S, *t++);
323
0
                    d++;
324
0
                    len -= CHUNKSIZE;
325
0
                } while (len > 0);
326
0
            } else
327
0
#endif /* !defined(T_SKEW) */
328
0
            {
329
781k
                do {
330
781k
                    FETCH_S;
331
781k
                    FETCH_T;
332
781k
                    SPECIFIC_CODE(*d, *d, S, T);
333
781k
                    d++;
334
781k
                    len -= CHUNKSIZE;
335
781k
                } while (len > 0);
336
0
            }
337
382k
        }
338
388k
    }
339
    /* Unaligned right hand case */
340
1.08M
    SAFE_FETCH_S(0,skewflags & 4);
341
1.08M
    SAFE_FETCH_T(0,skewflags & 8);
342
1.08M
    SPECIFIC_CODE(D, *d, S, T);
343
1.08M
    *d = (*d & rmask) | (D & ~rmask);
344
1.08M
}
Unexecuted instantiation: gsroprun.c:notS_rop_run1_const_t
Unexecuted instantiation: gsroprun.c:invert_rop_run1
Unexecuted instantiation: gsroprun.c:xor_rop_run1_const_t
gsroprun.c:sets_rop_run1
Line
Count
Source
118
1.07M
{
119
#ifndef SPECIFIC_CODE
120
    rop_proc     proc = rop_proc_table[op->rop];
121
#define SPECIFIC_CODE(OUT_, D_,S_,T_) OUT_ = proc(D_,S_,T_)
122
#endif /* !defined(SPECIFIC_CODE) */
123
1.07M
    CHUNK        lmask, rmask;
124
1.07M
#ifdef S_USED
125
#ifdef S_CONST
126
    CHUNK        S = (CHUNK)op->s.c;
127
#else /* !defined(S_CONST) */
128
1.07M
    const CHUNK *s = (CHUNK *)(void *)op->s.b.ptr;
129
1.07M
    CHUNK        S;
130
1.07M
    int          s_skew;
131
1.07M
#endif /* !defined(S_CONST) */
132
#else /* !defined(S_USED) */
133
#define S 0
134
#undef S_CONST
135
#endif /* !defined(S_USED) */
136
#ifdef T_USED
137
#ifdef T_CONST
138
    CHUNK        T = (CHUNK)op->t.c;
139
#else /* !defined(T_CONST) */
140
    const CHUNK *t = (CHUNK *)(void *)op->t.b.ptr;
141
    CHUNK        T;
142
    int          t_skew;
143
#endif /* !defined(T_CONST) */
144
#else /* !defined(T_USED) */
145
1.07M
#define T 0
146
1.07M
#undef T_CONST
147
1.07M
#endif /* !defined(T_USED) */
148
1.07M
#if defined(S_SKEW) || defined(T_SKEW)
149
1.07M
    int skewflags = 0;
150
1.07M
#endif
151
1.07M
    CHUNK        D;
152
1.07M
    int          dpos = op->dpos;
153
1.07M
    CHUNK       *d = (CHUNK *)(void *)d_;
154
155
    /* Align d to CHUNKSIZE */
156
1.07M
    ADJUST_TO_CHUNK(d,dpos);
157
158
    /* On entry len = length in 'depth' chunks. Change it to be the length
159
     * in bits, and add on the number of bits we skip at the start of the
160
     * run. */
161
1.07M
    len    = len * op->depth + dpos;
162
163
    /* lmask = the set of bits to alter in the output bitmap on the left
164
     * hand edge of the run. rmask = the set of bits NOT to alter in the
165
     * output bitmap on the right hand edge of the run. */
166
1.07M
    lmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & dpos)));
167
1.07M
    rmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & len)));
168
1.07M
    if (rmask == CHUNKONES) rmask = 0;
169
170
#if defined(S_CONST) || defined(T_CONST)
171
    /* S and T should be supplied as 'depth' bits. Duplicate them up to be
172
     * byte size (if they are supplied byte sized, that's fine too). */
173
    if (op->depth & 1) {
174
#ifdef S_CONST
175
        S |= S<<1;
176
#endif /* !defined(S_CONST) */
177
#ifdef T_CONST
178
        T |= T<<1;
179
#endif /* !defined(T_CONST) */
180
    }
181
    if (op->depth & 3) {
182
#ifdef S_CONST
183
        S |= S<<2;
184
#endif /* !defined(S_CONST) */
185
#ifdef T_CONST
186
        T |= T<<2;
187
#endif /* !defined(T_CONST) */
188
    }
189
    if (op->depth & 7) {
190
#ifdef S_CONST
191
        S |= S<<4;
192
#endif /* !defined(S_CONST) */
193
#ifdef T_CONST
194
        T |= T<<4;
195
#endif /* !defined(T_CONST) */
196
    }
197
#if CHUNKSIZE > 8
198
    if (op->depth & 15) {
199
#ifdef S_CONST
200
        S |= S<<8;
201
#endif /* !defined(S_CONST) */
202
#ifdef T_CONST
203
        T |= T<<8;
204
#endif /* !defined(T_CONST) */
205
    }
206
#endif /* CHUNKSIZE > 8 */
207
#if CHUNKSIZE > 16
208
    if (op->depth & 31) {
209
#ifdef S_CONST
210
        S |= S<<16;
211
#endif /* !defined(S_CONST) */
212
#ifdef T_CONST
213
        T |= T<<16;
214
#endif /* !defined(T_CONST) */
215
    }
216
#endif /* CHUNKSIZE > 16 */
217
#endif /* defined(S_CONST) || defined(T_CONST) */
218
219
    /* Note #1: This mirrors what the original code did, but I think it has
220
     * the risk of moving s and t back beyond officially allocated space. We
221
     * may be saved by the fact that all blocks have a word or two in front
222
     * of them due to the allocator. If we ever get valgrind properly marking
223
     * allocated blocks as readable etc, then this may throw some spurious
224
     * errors. RJW. */
225
1.07M
#ifdef S_SKEW
226
1.07M
    {
227
1.07M
        int slen, slen2;
228
1.07M
        int spos = op->s.b.pos;
229
1.07M
        ADJUST_TO_CHUNK(s, spos);
230
1.07M
        s_skew = spos - dpos;
231
1.07M
        if (s_skew < 0) {
232
1.07M
            s_skew += CHUNKSIZE;
233
1.07M
            s--;
234
1.07M
            skewflags |= 1; /* Suppress reading off left edge */
235
1.07M
        }
236
        /* We are allowed to read all the data bits, so: len - dpos + tpos
237
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
238
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
239
         * This is larger, then suppress. */
240
1.07M
        slen  = (len + s_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
241
1.07M
        slen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
242
1.07M
        if ((s_skew == 0) || (slen < slen2)) {
243
75.5k
            skewflags |= 4; /* Suppress reading off the right edge */
244
75.5k
        }
245
1.07M
    }
246
1.07M
#endif /* !defined(S_SKEW) */
247
#ifdef T_SKEW
248
    {
249
        int tlen, tlen2;
250
        int tpos = op->t.b.pos;
251
        ADJUST_TO_CHUNK(t, tpos);
252
        t_skew = tpos - dpos;
253
        if (t_skew < 0) {
254
            t_skew += CHUNKSIZE;
255
            t--;
256
            skewflags |= 2; /* Suppress reading off left edge */
257
        }
258
        /* We are allowed to read all the data bits, so: len - dpos + tpos
259
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
260
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
261
         * This is larger, then suppress. */
262
        tlen  = (len + t_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
263
        tlen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
264
        if ((t_skew == 0) || (tlen < tlen2)) {
265
            skewflags |= 8; /* Suppress reading off the right edge */
266
        }
267
    }
268
#endif /* !defined(T_SKEW) */
269
270
1.07M
    len -= CHUNKSIZE; /* len = bytes to do - CHUNKSIZE */
271
    /* len <= 0 means 1 word or less to do */
272
1.07M
    if (len <= 0) {
273
        /* Short case - starts and ends in the same chunk */
274
0
        lmask &= ~rmask; /* Combined mask = bits to alter */
275
0
        SAFE_FETCH_S(skewflags & 1,skewflags & 4);
276
0
        SAFE_FETCH_T(skewflags & 2,skewflags & 8);
277
0
        SPECIFIC_CODE(D, *d, S, T);
278
0
        *d = (*d & ~lmask) | (D & lmask);
279
0
        return;
280
0
    }
281
1.07M
    if ((lmask != CHUNKONES)
282
1.07M
#if defined(S_SKEW) || defined(T_SKEW)
283
1.07M
        || (skewflags & 3)
284
1.07M
#endif
285
1.07M
        ) {
286
        /* Unaligned left hand case */
287
1.07M
        SAFE_FETCH_S(skewflags & 1,s_skew == 0);
288
1.07M
        SAFE_FETCH_T(skewflags & 2,t_skew == 0);
289
1.07M
        SPECIFIC_CODE(D, *d, S, T);
290
1.07M
        *d = (*d & ~lmask) | (D & lmask);
291
1.07M
        d++;
292
1.07M
        len -= CHUNKSIZE;
293
1.07M
    }
294
1.07M
    if (len > 0) {
295
        /* Simple middle case (complete destination chunks). */
296
379k
#ifdef S_SKEW
297
379k
        if (s_skew == 0) {
298
#ifdef T_SKEW
299
            if (t_skew == 0) {
300
                do {
301
                    SPECIFIC_CODE(*d, *d, *s++, *t++);
302
                    d++;
303
                    len -= CHUNKSIZE;
304
                } while (len > 0);
305
            } else
306
#endif /* !defined(T_SKEW) */
307
1.36k
            {
308
4.07k
                do {
309
4.07k
                    FETCH_T;
310
4.07k
                    SPECIFIC_CODE(*d, *d, *s++, T);
311
4.07k
                    d++;
312
4.07k
                    len -= CHUNKSIZE;
313
4.07k
                } while (len > 0);
314
1.36k
            }
315
1.36k
        } else
316
378k
#endif /* !defined(S_SKEW) */
317
378k
        {
318
#ifdef T_SKEW
319
            if (t_skew == 0) {
320
                do {
321
                    FETCH_S;
322
                    SPECIFIC_CODE(*d, *d, S, *t++);
323
                    d++;
324
                    len -= CHUNKSIZE;
325
                } while (len > 0);
326
            } else
327
#endif /* !defined(T_SKEW) */
328
378k
            {
329
659k
                do {
330
659k
                    FETCH_S;
331
659k
                    FETCH_T;
332
659k
                    SPECIFIC_CODE(*d, *d, S, T);
333
659k
                    d++;
334
659k
                    len -= CHUNKSIZE;
335
659k
                } while (len > 0);
336
378k
            }
337
378k
        }
338
379k
    }
339
    /* Unaligned right hand case */
340
1.07M
    SAFE_FETCH_S(0,skewflags & 4);
341
1.07M
    SAFE_FETCH_T(0,skewflags & 8);
342
1.07M
    SPECIFIC_CODE(D, *d, S, T);
343
1.07M
    *d = (*d & rmask) | (D & ~rmask);
344
1.07M
}
gsroprun.c:dors_rop_run1_const_t
Line
Count
Source
118
1.62k
{
119
#ifndef SPECIFIC_CODE
120
    rop_proc     proc = rop_proc_table[op->rop];
121
#define SPECIFIC_CODE(OUT_, D_,S_,T_) OUT_ = proc(D_,S_,T_)
122
#endif /* !defined(SPECIFIC_CODE) */
123
1.62k
    CHUNK        lmask, rmask;
124
1.62k
#ifdef S_USED
125
#ifdef S_CONST
126
    CHUNK        S = (CHUNK)op->s.c;
127
#else /* !defined(S_CONST) */
128
1.62k
    const CHUNK *s = (CHUNK *)(void *)op->s.b.ptr;
129
1.62k
    CHUNK        S;
130
1.62k
    int          s_skew;
131
1.62k
#endif /* !defined(S_CONST) */
132
#else /* !defined(S_USED) */
133
#define S 0
134
#undef S_CONST
135
#endif /* !defined(S_USED) */
136
#ifdef T_USED
137
#ifdef T_CONST
138
    CHUNK        T = (CHUNK)op->t.c;
139
#else /* !defined(T_CONST) */
140
    const CHUNK *t = (CHUNK *)(void *)op->t.b.ptr;
141
    CHUNK        T;
142
    int          t_skew;
143
#endif /* !defined(T_CONST) */
144
#else /* !defined(T_USED) */
145
1.62k
#define T 0
146
1.62k
#undef T_CONST
147
1.62k
#endif /* !defined(T_USED) */
148
1.62k
#if defined(S_SKEW) || defined(T_SKEW)
149
1.62k
    int skewflags = 0;
150
1.62k
#endif
151
1.62k
    CHUNK        D;
152
1.62k
    int          dpos = op->dpos;
153
1.62k
    CHUNK       *d = (CHUNK *)(void *)d_;
154
155
    /* Align d to CHUNKSIZE */
156
1.62k
    ADJUST_TO_CHUNK(d,dpos);
157
158
    /* On entry len = length in 'depth' chunks. Change it to be the length
159
     * in bits, and add on the number of bits we skip at the start of the
160
     * run. */
161
1.62k
    len    = len * op->depth + dpos;
162
163
    /* lmask = the set of bits to alter in the output bitmap on the left
164
     * hand edge of the run. rmask = the set of bits NOT to alter in the
165
     * output bitmap on the right hand edge of the run. */
166
1.62k
    lmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & dpos)));
167
1.62k
    rmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & len)));
168
1.62k
    if (rmask == CHUNKONES) rmask = 0;
169
170
#if defined(S_CONST) || defined(T_CONST)
171
    /* S and T should be supplied as 'depth' bits. Duplicate them up to be
172
     * byte size (if they are supplied byte sized, that's fine too). */
173
    if (op->depth & 1) {
174
#ifdef S_CONST
175
        S |= S<<1;
176
#endif /* !defined(S_CONST) */
177
#ifdef T_CONST
178
        T |= T<<1;
179
#endif /* !defined(T_CONST) */
180
    }
181
    if (op->depth & 3) {
182
#ifdef S_CONST
183
        S |= S<<2;
184
#endif /* !defined(S_CONST) */
185
#ifdef T_CONST
186
        T |= T<<2;
187
#endif /* !defined(T_CONST) */
188
    }
189
    if (op->depth & 7) {
190
#ifdef S_CONST
191
        S |= S<<4;
192
#endif /* !defined(S_CONST) */
193
#ifdef T_CONST
194
        T |= T<<4;
195
#endif /* !defined(T_CONST) */
196
    }
197
#if CHUNKSIZE > 8
198
    if (op->depth & 15) {
199
#ifdef S_CONST
200
        S |= S<<8;
201
#endif /* !defined(S_CONST) */
202
#ifdef T_CONST
203
        T |= T<<8;
204
#endif /* !defined(T_CONST) */
205
    }
206
#endif /* CHUNKSIZE > 8 */
207
#if CHUNKSIZE > 16
208
    if (op->depth & 31) {
209
#ifdef S_CONST
210
        S |= S<<16;
211
#endif /* !defined(S_CONST) */
212
#ifdef T_CONST
213
        T |= T<<16;
214
#endif /* !defined(T_CONST) */
215
    }
216
#endif /* CHUNKSIZE > 16 */
217
#endif /* defined(S_CONST) || defined(T_CONST) */
218
219
    /* Note #1: This mirrors what the original code did, but I think it has
220
     * the risk of moving s and t back beyond officially allocated space. We
221
     * may be saved by the fact that all blocks have a word or two in front
222
     * of them due to the allocator. If we ever get valgrind properly marking
223
     * allocated blocks as readable etc, then this may throw some spurious
224
     * errors. RJW. */
225
1.62k
#ifdef S_SKEW
226
1.62k
    {
227
1.62k
        int slen, slen2;
228
1.62k
        int spos = op->s.b.pos;
229
1.62k
        ADJUST_TO_CHUNK(s, spos);
230
1.62k
        s_skew = spos - dpos;
231
1.62k
        if (s_skew < 0) {
232
0
            s_skew += CHUNKSIZE;
233
0
            s--;
234
0
            skewflags |= 1; /* Suppress reading off left edge */
235
0
        }
236
        /* We are allowed to read all the data bits, so: len - dpos + tpos
237
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
238
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
239
         * This is larger, then suppress. */
240
1.62k
        slen  = (len + s_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
241
1.62k
        slen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
242
1.62k
        if ((s_skew == 0) || (slen < slen2)) {
243
1.62k
            skewflags |= 4; /* Suppress reading off the right edge */
244
1.62k
        }
245
1.62k
    }
246
1.62k
#endif /* !defined(S_SKEW) */
247
#ifdef T_SKEW
248
    {
249
        int tlen, tlen2;
250
        int tpos = op->t.b.pos;
251
        ADJUST_TO_CHUNK(t, tpos);
252
        t_skew = tpos - dpos;
253
        if (t_skew < 0) {
254
            t_skew += CHUNKSIZE;
255
            t--;
256
            skewflags |= 2; /* Suppress reading off left edge */
257
        }
258
        /* We are allowed to read all the data bits, so: len - dpos + tpos
259
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
260
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
261
         * This is larger, then suppress. */
262
        tlen  = (len + t_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
263
        tlen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
264
        if ((t_skew == 0) || (tlen < tlen2)) {
265
            skewflags |= 8; /* Suppress reading off the right edge */
266
        }
267
    }
268
#endif /* !defined(T_SKEW) */
269
270
1.62k
    len -= CHUNKSIZE; /* len = bytes to do - CHUNKSIZE */
271
    /* len <= 0 means 1 word or less to do */
272
1.62k
    if (len <= 0) {
273
        /* Short case - starts and ends in the same chunk */
274
0
        lmask &= ~rmask; /* Combined mask = bits to alter */
275
0
        SAFE_FETCH_S(skewflags & 1,skewflags & 4);
276
0
        SAFE_FETCH_T(skewflags & 2,skewflags & 8);
277
0
        SPECIFIC_CODE(D, *d, S, T);
278
0
        *d = (*d & ~lmask) | (D & lmask);
279
0
        return;
280
0
    }
281
1.62k
    if ((lmask != CHUNKONES)
282
1.62k
#if defined(S_SKEW) || defined(T_SKEW)
283
1.62k
        || (skewflags & 3)
284
1.62k
#endif
285
1.62k
        ) {
286
        /* Unaligned left hand case */
287
0
        SAFE_FETCH_S(skewflags & 1,s_skew == 0);
288
0
        SAFE_FETCH_T(skewflags & 2,t_skew == 0);
289
0
        SPECIFIC_CODE(D, *d, S, T);
290
0
        *d = (*d & ~lmask) | (D & lmask);
291
0
        d++;
292
0
        len -= CHUNKSIZE;
293
0
    }
294
1.62k
    if (len > 0) {
295
        /* Simple middle case (complete destination chunks). */
296
1.62k
#ifdef S_SKEW
297
1.62k
        if (s_skew == 0) {
298
#ifdef T_SKEW
299
            if (t_skew == 0) {
300
                do {
301
                    SPECIFIC_CODE(*d, *d, *s++, *t++);
302
                    d++;
303
                    len -= CHUNKSIZE;
304
                } while (len > 0);
305
            } else
306
#endif /* !defined(T_SKEW) */
307
407
            {
308
12.6k
                do {
309
12.6k
                    FETCH_T;
310
12.6k
                    SPECIFIC_CODE(*d, *d, *s++, T);
311
12.6k
                    d++;
312
12.6k
                    len -= CHUNKSIZE;
313
12.6k
                } while (len > 0);
314
407
            }
315
407
        } else
316
1.21k
#endif /* !defined(S_SKEW) */
317
1.21k
        {
318
#ifdef T_SKEW
319
            if (t_skew == 0) {
320
                do {
321
                    FETCH_S;
322
                    SPECIFIC_CODE(*d, *d, S, *t++);
323
                    d++;
324
                    len -= CHUNKSIZE;
325
                } while (len > 0);
326
            } else
327
#endif /* !defined(T_SKEW) */
328
1.21k
            {
329
37.6k
                do {
330
37.6k
                    FETCH_S;
331
37.6k
                    FETCH_T;
332
37.6k
                    SPECIFIC_CODE(*d, *d, S, T);
333
37.6k
                    d++;
334
37.6k
                    len -= CHUNKSIZE;
335
37.6k
                } while (len > 0);
336
1.21k
            }
337
1.21k
        }
338
1.62k
    }
339
    /* Unaligned right hand case */
340
1.62k
    SAFE_FETCH_S(0,skewflags & 4);
341
1.62k
    SAFE_FETCH_T(0,skewflags & 8);
342
1.62k
    SPECIFIC_CODE(D, *d, S, T);
343
1.62k
    *d = (*d & rmask) | (D & ~rmask);
344
1.62k
}
Unexecuted instantiation: gsroprun.c:generic_rop_run1
gsroprun.c:generic_rop_run1_const_t
Line
Count
Source
118
7.63k
{
119
7.63k
#ifndef SPECIFIC_CODE
120
7.63k
    rop_proc     proc = rop_proc_table[op->rop];
121
7.63k
#define SPECIFIC_CODE(OUT_, D_,S_,T_) OUT_ = proc(D_,S_,T_)
122
7.63k
#endif /* !defined(SPECIFIC_CODE) */
123
7.63k
    CHUNK        lmask, rmask;
124
7.63k
#ifdef S_USED
125
#ifdef S_CONST
126
    CHUNK        S = (CHUNK)op->s.c;
127
#else /* !defined(S_CONST) */
128
7.63k
    const CHUNK *s = (CHUNK *)(void *)op->s.b.ptr;
129
7.63k
    CHUNK        S;
130
7.63k
    int          s_skew;
131
7.63k
#endif /* !defined(S_CONST) */
132
#else /* !defined(S_USED) */
133
#define S 0
134
#undef S_CONST
135
#endif /* !defined(S_USED) */
136
7.63k
#ifdef T_USED
137
7.63k
#ifdef T_CONST
138
7.63k
    CHUNK        T = (CHUNK)op->t.c;
139
#else /* !defined(T_CONST) */
140
    const CHUNK *t = (CHUNK *)(void *)op->t.b.ptr;
141
    CHUNK        T;
142
    int          t_skew;
143
#endif /* !defined(T_CONST) */
144
#else /* !defined(T_USED) */
145
#define T 0
146
#undef T_CONST
147
#endif /* !defined(T_USED) */
148
7.63k
#if defined(S_SKEW) || defined(T_SKEW)
149
7.63k
    int skewflags = 0;
150
7.63k
#endif
151
7.63k
    CHUNK        D;
152
7.63k
    int          dpos = op->dpos;
153
7.63k
    CHUNK       *d = (CHUNK *)(void *)d_;
154
155
    /* Align d to CHUNKSIZE */
156
7.63k
    ADJUST_TO_CHUNK(d,dpos);
157
158
    /* On entry len = length in 'depth' chunks. Change it to be the length
159
     * in bits, and add on the number of bits we skip at the start of the
160
     * run. */
161
7.63k
    len    = len * op->depth + dpos;
162
163
    /* lmask = the set of bits to alter in the output bitmap on the left
164
     * hand edge of the run. rmask = the set of bits NOT to alter in the
165
     * output bitmap on the right hand edge of the run. */
166
7.63k
    lmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & dpos)));
167
7.63k
    rmask  = RE((CHUNKONES>>((CHUNKSIZE-1) & len)));
168
7.63k
    if (rmask == CHUNKONES) rmask = 0;
169
170
7.63k
#if defined(S_CONST) || defined(T_CONST)
171
    /* S and T should be supplied as 'depth' bits. Duplicate them up to be
172
     * byte size (if they are supplied byte sized, that's fine too). */
173
7.63k
    if (op->depth & 1) {
174
#ifdef S_CONST
175
        S |= S<<1;
176
#endif /* !defined(S_CONST) */
177
7.63k
#ifdef T_CONST
178
7.63k
        T |= T<<1;
179
7.63k
#endif /* !defined(T_CONST) */
180
7.63k
    }
181
7.63k
    if (op->depth & 3) {
182
#ifdef S_CONST
183
        S |= S<<2;
184
#endif /* !defined(S_CONST) */
185
7.63k
#ifdef T_CONST
186
7.63k
        T |= T<<2;
187
7.63k
#endif /* !defined(T_CONST) */
188
7.63k
    }
189
7.63k
    if (op->depth & 7) {
190
#ifdef S_CONST
191
        S |= S<<4;
192
#endif /* !defined(S_CONST) */
193
7.63k
#ifdef T_CONST
194
7.63k
        T |= T<<4;
195
7.63k
#endif /* !defined(T_CONST) */
196
7.63k
    }
197
7.63k
#if CHUNKSIZE > 8
198
7.63k
    if (op->depth & 15) {
199
#ifdef S_CONST
200
        S |= S<<8;
201
#endif /* !defined(S_CONST) */
202
7.63k
#ifdef T_CONST
203
7.63k
        T |= T<<8;
204
7.63k
#endif /* !defined(T_CONST) */
205
7.63k
    }
206
7.63k
#endif /* CHUNKSIZE > 8 */
207
7.63k
#if CHUNKSIZE > 16
208
7.63k
    if (op->depth & 31) {
209
#ifdef S_CONST
210
        S |= S<<16;
211
#endif /* !defined(S_CONST) */
212
7.63k
#ifdef T_CONST
213
7.63k
        T |= T<<16;
214
7.63k
#endif /* !defined(T_CONST) */
215
7.63k
    }
216
7.63k
#endif /* CHUNKSIZE > 16 */
217
7.63k
#endif /* defined(S_CONST) || defined(T_CONST) */
218
219
    /* Note #1: This mirrors what the original code did, but I think it has
220
     * the risk of moving s and t back beyond officially allocated space. We
221
     * may be saved by the fact that all blocks have a word or two in front
222
     * of them due to the allocator. If we ever get valgrind properly marking
223
     * allocated blocks as readable etc, then this may throw some spurious
224
     * errors. RJW. */
225
7.63k
#ifdef S_SKEW
226
7.63k
    {
227
7.63k
        int slen, slen2;
228
7.63k
        int spos = op->s.b.pos;
229
7.63k
        ADJUST_TO_CHUNK(s, spos);
230
7.63k
        s_skew = spos - dpos;
231
7.63k
        if (s_skew < 0) {
232
0
            s_skew += CHUNKSIZE;
233
0
            s--;
234
0
            skewflags |= 1; /* Suppress reading off left edge */
235
0
        }
236
        /* We are allowed to read all the data bits, so: len - dpos + tpos
237
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
238
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
239
         * This is larger, then suppress. */
240
7.63k
        slen  = (len + s_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
241
7.63k
        slen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
242
7.63k
        if ((s_skew == 0) || (slen < slen2)) {
243
7.63k
            skewflags |= 4; /* Suppress reading off the right edge */
244
7.63k
        }
245
7.63k
    }
246
7.63k
#endif /* !defined(S_SKEW) */
247
#ifdef T_SKEW
248
    {
249
        int tlen, tlen2;
250
        int tpos = op->t.b.pos;
251
        ADJUST_TO_CHUNK(t, tpos);
252
        t_skew = tpos - dpos;
253
        if (t_skew < 0) {
254
            t_skew += CHUNKSIZE;
255
            t--;
256
            skewflags |= 2; /* Suppress reading off left edge */
257
        }
258
        /* We are allowed to read all the data bits, so: len - dpos + tpos
259
         * We're allowed to read in CHUNKS, so: CHUNKUP(len-dpos+tpos).
260
         * This code will actually read CHUNKUP(len)+CHUNKSIZE bits. If
261
         * This is larger, then suppress. */
262
        tlen  = (len + t_skew    + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
263
        tlen2 = (len + CHUNKSIZE + CHUNKSIZE-1) & ~(CHUNKSIZE-1);
264
        if ((t_skew == 0) || (tlen < tlen2)) {
265
            skewflags |= 8; /* Suppress reading off the right edge */
266
        }
267
    }
268
#endif /* !defined(T_SKEW) */
269
270
7.63k
    len -= CHUNKSIZE; /* len = bytes to do - CHUNKSIZE */
271
    /* len <= 0 means 1 word or less to do */
272
7.63k
    if (len <= 0) {
273
        /* Short case - starts and ends in the same chunk */
274
0
        lmask &= ~rmask; /* Combined mask = bits to alter */
275
0
        SAFE_FETCH_S(skewflags & 1,skewflags & 4);
276
0
        SAFE_FETCH_T(skewflags & 2,skewflags & 8);
277
0
        SPECIFIC_CODE(D, *d, S, T);
278
0
        *d = (*d & ~lmask) | (D & lmask);
279
0
        return;
280
0
    }
281
7.63k
    if ((lmask != CHUNKONES)
282
7.63k
#if defined(S_SKEW) || defined(T_SKEW)
283
7.63k
        || (skewflags & 3)
284
7.63k
#endif
285
7.63k
        ) {
286
        /* Unaligned left hand case */
287
0
        SAFE_FETCH_S(skewflags & 1,s_skew == 0);
288
0
        SAFE_FETCH_T(skewflags & 2,t_skew == 0);
289
0
        SPECIFIC_CODE(D, *d, S, T);
290
0
        *d = (*d & ~lmask) | (D & lmask);
291
0
        d++;
292
0
        len -= CHUNKSIZE;
293
0
    }
294
7.63k
    if (len > 0) {
295
        /* Simple middle case (complete destination chunks). */
296
7.63k
#ifdef S_SKEW
297
7.63k
        if (s_skew == 0) {
298
#ifdef T_SKEW
299
            if (t_skew == 0) {
300
                do {
301
                    SPECIFIC_CODE(*d, *d, *s++, *t++);
302
                    d++;
303
                    len -= CHUNKSIZE;
304
                } while (len > 0);
305
            } else
306
#endif /* !defined(T_SKEW) */
307
4.90k
            {
308
87.9k
                do {
309
87.9k
                    FETCH_T;
310
87.9k
                    SPECIFIC_CODE(*d, *d, *s++, T);
311
87.9k
                    d++;
312
87.9k
                    len -= CHUNKSIZE;
313
87.9k
                } while (len > 0);
314
4.90k
            }
315
4.90k
        } else
316
2.73k
#endif /* !defined(S_SKEW) */
317
2.73k
        {
318
#ifdef T_SKEW
319
            if (t_skew == 0) {
320
                do {
321
                    FETCH_S;
322
                    SPECIFIC_CODE(*d, *d, S, *t++);
323
                    d++;
324
                    len -= CHUNKSIZE;
325
                } while (len > 0);
326
            } else
327
#endif /* !defined(T_SKEW) */
328
2.73k
            {
329
84.6k
                do {
330
84.6k
                    FETCH_S;
331
84.6k
                    FETCH_T;
332
84.6k
                    SPECIFIC_CODE(*d, *d, S, T);
333
84.6k
                    d++;
334
84.6k
                    len -= CHUNKSIZE;
335
84.6k
                } while (len > 0);
336
2.73k
            }
337
2.73k
        }
338
7.63k
    }
339
    /* Unaligned right hand case */
340
7.63k
    SAFE_FETCH_S(0,skewflags & 4);
341
7.63k
    SAFE_FETCH_T(0,skewflags & 8);
342
7.63k
    SPECIFIC_CODE(D, *d, S, T);
343
7.63k
    *d = (*d & rmask) | (D & ~rmask);
344
7.63k
}
Unexecuted instantiation: gsroprun.c:generic_rop_run1_const_st
345
346
#undef ADJUST_TO_CHUNK
347
#undef CHUNKSIZE
348
#undef CHUNK
349
#undef CHUNKONES
350
#undef FETCH_S
351
#undef FETCH_T
352
#undef SAFE_FETCH_S
353
#undef SAFE_FETCH_T
354
#undef RE
355
#undef S
356
#undef S_USED
357
#undef S_CONST
358
#undef S_SKEW
359
#undef SKEW_FETCH
360
#undef SAFE_SKEW_FETCH
361
#undef SPECIFIC_CODE
362
#undef SPECIFIC_ROP
363
#undef T
364
#undef T_USED
365
#undef T_CONST
366
#undef T_SKEW
367
#undef TEMPLATE_NAME
368
#undef ROP_PTRDIFF_T
369
370
#else
371
int dummy;
372
#endif