Annotation of embedaddon/pcre/pcre_jit_compile.c, revision 1.1.1.1
1.1 misho 1: /*************************************************
2: * Perl-Compatible Regular Expressions *
3: *************************************************/
4:
5: /* PCRE is a library of functions to support regular expressions whose syntax
6: and semantics are as close as possible to those of the Perl 5 language.
7:
8: Written by Philip Hazel
9: Copyright (c) 1997-2008 University of Cambridge
10:
11: The machine code generator part (this module) was written by Zoltan Herczeg
12: Copyright (c) 2010-2011
13:
14: -----------------------------------------------------------------------------
15: Redistribution and use in source and binary forms, with or without
16: modification, are permitted provided that the following conditions are met:
17:
18: * Redistributions of source code must retain the above copyright notice,
19: this list of conditions and the following disclaimer.
20:
21: * Redistributions in binary form must reproduce the above copyright
22: notice, this list of conditions and the following disclaimer in the
23: documentation and/or other materials provided with the distribution.
24:
25: * Neither the name of the University of Cambridge nor the names of its
26: contributors may be used to endorse or promote products derived from
27: this software without specific prior written permission.
28:
29: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
30: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
33: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39: POSSIBILITY OF SUCH DAMAGE.
40: -----------------------------------------------------------------------------
41: */
42:
43: #ifdef HAVE_CONFIG_H
44: #include "config.h"
45: #endif
46:
47: #include "pcre_internal.h"
48:
49: #ifdef SUPPORT_JIT
50:
51: /* All-in-one: Since we use the JIT compiler only from here,
52: we just include it. This way we don't need to touch the build
53: system files. */
54:
55: #define SLJIT_MALLOC(size) (pcre_malloc)(size)
56: #define SLJIT_FREE(ptr) (pcre_free)(ptr)
57: #define SLJIT_CONFIG_AUTO 1
58: #define SLJIT_CONFIG_STATIC 1
59: #define SLJIT_VERBOSE 0
60: #define SLJIT_DEBUG 0
61:
62: #include "sljit/sljitLir.c"
63:
64: #if defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED
65: #error "Unsupported architecture"
66: #endif
67:
68: /* Allocate memory on the stack. Fast, but limited size. */
69: #define LOCAL_SPACE_SIZE 32768
70:
71: #define STACK_GROWTH_RATE 8192
72:
73: /* Enable to check that the allocation could destroy temporaries. */
74: #if defined SLJIT_DEBUG && SLJIT_DEBUG
75: #define DESTROY_REGISTERS 1
76: #endif
77:
78: /*
79: Short summary about the backtracking mechanism empolyed by the jit code generator:
80:
81: The code generator follows the recursive nature of the PERL compatible regular
82: expressions. The basic blocks of regular expressions are condition checkers
83: whose execute different commands depending on the result of the condition check.
84: The relationship between the operators can be horizontal (concatenation) and
85: vertical (sub-expression) (See struct fallback_common for more details).
86:
87: 'ab' - 'a' and 'b' regexps are concatenated
88: 'a+' - 'a' is the sub-expression of the '+' operator
89:
90: The condition checkers are boolean (true/false) checkers. Machine code is generated
91: for the checker itself and for the actions depending on the result of the checker.
92: The 'true' case is called as the hot path (expected path), and the other is called as
93: the 'fallback' path. Branch instructions are expesive for all CPUs, so we avoid taken
94: branches on the hot path.
95:
96: Greedy star operator (*) :
97: Hot path: match happens.
98: Fallback path: match failed.
99: Non-greedy star operator (*?) :
100: Hot path: no need to perform a match.
101: Fallback path: match is required.
102:
103: The following example shows how the code generated for a capturing bracket
104: with two alternatives. Let A, B, C, D are arbirary regular expressions, and
105: we have the following regular expression:
106:
107: A(B|C)D
108:
109: The generated code will be the following:
110:
111: A hot path
112: '(' hot path (pushing arguments to the stack)
113: B hot path
114: ')' hot path (pushing arguments to the stack)
115: D hot path
116: return with successful match
117:
118: D fallback path
119: ')' fallback path (If we arrived from "C" jump to the fallback of "C")
120: B fallback path
121: C expected path
122: jump to D hot path
123: C fallback path
124: A fallback path
125:
126: Notice, that the order of fallback code paths are the opposite of the fast
127: code paths. In this way the topmost value on the stack is always belong
128: to the current fallback code path. The fallback code path must check
129: whether there is a next alternative. If so, it needs to jump back to
130: the hot path eventually. Otherwise it needs to clear out its own stack
131: frame and continue the execution on the fallback code paths.
132: */
133:
134: /*
135: Saved stack frames:
136:
137: Atomic blocks and asserts require reloading the values of local variables
138: when the fallback mechanism performed. Because of OP_RECURSE, the locals
139: are not necessarly known in compile time, thus we need a dynamic restore
140: mechanism.
141:
142: The stack frames are stored in a chain list, and have the following format:
143: ([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ]
144:
145: Thus we can restore the locals to a particular point in the stack.
146: */
147:
148: typedef struct jit_arguments {
149: /* Pointers first. */
150: struct sljit_stack *stack;
151: PCRE_SPTR str;
152: PCRE_SPTR begin;
153: PCRE_SPTR end;
154: int *offsets;
155: uschar *ptr;
156: /* Everything else after. */
157: int offsetcount;
158: int calllimit;
159: uschar notbol;
160: uschar noteol;
161: uschar notempty;
162: uschar notempty_atstart;
163: } jit_arguments;
164:
165: typedef struct executable_function {
166: void *executable_func;
167: pcre_jit_callback callback;
168: void *userdata;
169: sljit_uw executable_size;
170: } executable_function;
171:
172: typedef struct jump_list {
173: struct sljit_jump *jump;
174: struct jump_list *next;
175: } jump_list;
176:
177: enum stub_types { stack_alloc };
178:
179: typedef struct stub_list {
180: enum stub_types type;
181: int data;
182: struct sljit_jump *start;
183: struct sljit_label *leave;
184: struct stub_list *next;
185: } stub_list;
186:
187: typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);
188:
189: /* The following structure is the key data type for the recursive
190: code generator. It is allocated by compile_hotpath, and contains
191: the aguments for compile_fallbackpath. Must be the first member
192: of its descendants. */
193: typedef struct fallback_common {
194: /* Concatenation stack. */
195: struct fallback_common *prev;
196: jump_list *nextfallbacks;
197: /* Internal stack (for component operators). */
198: struct fallback_common *top;
199: jump_list *topfallbacks;
200: /* Opcode pointer. */
201: uschar *cc;
202: } fallback_common;
203:
204: typedef struct assert_fallback {
205: fallback_common common;
206: jump_list *condfailed;
207: /* Less than 0 (-1) if a frame is not needed. */
208: int framesize;
209: /* Points to our private memory word on the stack. */
210: int localptr;
211: /* For iterators. */
212: struct sljit_label *hotpath;
213: } assert_fallback;
214:
215: typedef struct bracket_fallback {
216: fallback_common common;
217: /* Where to coninue if an alternative is successfully matched. */
218: struct sljit_label *althotpath;
219: /* For rmin and rmax iterators. */
220: struct sljit_label *recursivehotpath;
221: /* For greedy ? operator. */
222: struct sljit_label *zerohotpath;
223: /* Contains the branches of a failed condition. */
224: union {
225: /* Both for OP_COND, OP_SCOND. */
226: jump_list *condfailed;
227: assert_fallback *assert;
228: /* For OP_ONCE. -1 if not needed. */
229: int framesize;
230: } u;
231: /* Points to our private memory word on the stack. */
232: int localptr;
233: } bracket_fallback;
234:
235: typedef struct bracketpos_fallback {
236: fallback_common common;
237: /* Points to our private memory word on the stack. */
238: int localptr;
239: /* Reverting stack is needed. */
240: int framesize;
241: /* Allocated stack size. */
242: int stacksize;
243: } bracketpos_fallback;
244:
245: typedef struct braminzero_fallback {
246: fallback_common common;
247: struct sljit_label *hotpath;
248: } braminzero_fallback;
249:
250: typedef struct iterator_fallback {
251: fallback_common common;
252: /* Next iteration. */
253: struct sljit_label *hotpath;
254: } iterator_fallback;
255:
256: typedef struct recurse_entry {
257: struct recurse_entry *next;
258: /* Contains the function entry. */
259: struct sljit_label *entry;
260: /* Collects the calls until the function is not created. */
261: jump_list *calls;
262: /* Points to the starting opcode. */
263: int start;
264: } recurse_entry;
265:
266: typedef struct recurse_fallback {
267: fallback_common common;
268: } recurse_fallback;
269:
270: typedef struct compiler_common {
271: struct sljit_compiler *compiler;
272: uschar *start;
273: int localsize;
274: int *localptrs;
275: const uschar *fcc;
276: sljit_w lcc;
277: int cbraptr;
278: int nltype;
279: int newline;
280: int bsr_nltype;
281: int endonly;
282: sljit_w ctypes;
283: sljit_uw name_table;
284: sljit_w name_count;
285: sljit_w name_entry_size;
286: struct sljit_label *acceptlabel;
287: stub_list *stubs;
288: recurse_entry *entries;
289: recurse_entry *currententry;
290: jump_list *accept;
291: jump_list *calllimit;
292: jump_list *stackalloc;
293: jump_list *revertframes;
294: jump_list *wordboundary;
295: jump_list *anynewline;
296: jump_list *hspace;
297: jump_list *vspace;
298: jump_list *casefulcmp;
299: jump_list *caselesscmp;
300: BOOL jscript_compat;
301: #ifdef SUPPORT_UTF8
302: BOOL utf8;
303: #ifdef SUPPORT_UCP
304: BOOL useucp;
305: #endif
306: jump_list *utf8readchar;
307: jump_list *utf8readtype8;
308: #endif
309: #ifdef SUPPORT_UCP
310: jump_list *getucd;
311: #endif
312: } compiler_common;
313:
314: /* For byte_sequence_compare. */
315:
316: typedef struct compare_context {
317: int length;
318: int sourcereg;
319: #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
320: int byteptr;
321: union {
322: int asint;
323: short asshort;
324: sljit_ub asbyte;
325: sljit_ub asbytes[4];
326: } c;
327: union {
328: int asint;
329: short asshort;
330: sljit_ub asbyte;
331: sljit_ub asbytes[4];
332: } oc;
333: #endif
334: } compare_context;
335:
336: enum {
337: frame_end = 0,
338: frame_setstrbegin = -1
339: };
340:
341: /* Used for accessing the elements of the stack. */
342: #define STACK(i) ((-(i) - 1) * (int)sizeof(sljit_w))
343:
344: #define TMP1 SLJIT_TEMPORARY_REG1
345: #define TMP2 SLJIT_TEMPORARY_REG3
346: #define TMP3 SLJIT_TEMPORARY_EREG2
347: #define STR_PTR SLJIT_GENERAL_REG1
348: #define STR_END SLJIT_GENERAL_REG2
349: #define STACK_TOP SLJIT_TEMPORARY_REG2
350: #define STACK_LIMIT SLJIT_GENERAL_REG3
351: #define ARGUMENTS SLJIT_GENERAL_EREG1
352: #define CALL_COUNT SLJIT_GENERAL_EREG2
353: #define RETURN_ADDR SLJIT_TEMPORARY_EREG1
354:
355: /* Locals layout. */
356: /* These two locals can be used by the current opcode. */
357: #define LOCALS0 (0 * sizeof(sljit_w))
358: #define LOCALS1 (1 * sizeof(sljit_w))
359: /* Two local variables for possessive quantifiers (char1 cannot use them). */
360: #define POSSESSIVE0 (2 * sizeof(sljit_w))
361: #define POSSESSIVE1 (3 * sizeof(sljit_w))
362: /* Head of the last recursion. */
363: #define RECURSIVE_HEAD (4 * sizeof(sljit_w))
364: /* Max limit of recursions. */
365: #define CALL_LIMIT (5 * sizeof(sljit_w))
366: /* Last known position of the requested byte. */
367: #define REQ_BYTE_PTR (6 * sizeof(sljit_w))
368: /* End pointer of the first line. */
369: #define FIRSTLINE_END (7 * sizeof(sljit_w))
370: /* The output vector is stored on the stack, and contains pointers
371: to characters. The vector data is divided into two groups: the first
372: group contains the start / end character pointers, and the second is
373: the start pointers when the end of the capturing group has not yet reached. */
374: #define OVECTOR_START (8 * sizeof(sljit_w))
375: #define OVECTOR(i) (OVECTOR_START + (i) * sizeof(sljit_w))
376: #define OVECTOR_PRIV(i) (common->cbraptr + (i) * sizeof(sljit_w))
377: #define PRIV(cc) (common->localptrs[(cc) - common->start])
378:
379: /* Shortcuts. */
380: #define DEFINE_COMPILER \
381: struct sljit_compiler *compiler = common->compiler
382: #define OP1(op, dst, dstw, src, srcw) \
383: sljit_emit_op1(compiler, (op), (dst), (dstw), (src), (srcw))
384: #define OP2(op, dst, dstw, src1, src1w, src2, src2w) \
385: sljit_emit_op2(compiler, (op), (dst), (dstw), (src1), (src1w), (src2), (src2w))
386: #define LABEL() \
387: sljit_emit_label(compiler)
388: #define JUMP(type) \
389: sljit_emit_jump(compiler, (type))
390: #define JUMPTO(type, label) \
391: sljit_set_label(sljit_emit_jump(compiler, (type)), (label))
392: #define JUMPHERE(jump) \
393: sljit_set_label((jump), sljit_emit_label(compiler))
394: #define CMP(type, src1, src1w, src2, src2w) \
395: sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))
396: #define CMPTO(type, src1, src1w, src2, src2w, label) \
397: sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))
398: #define COND_VALUE(op, dst, dstw, type) \
399: sljit_emit_cond_value(compiler, (op), (dst), (dstw), (type))
400:
401: static uschar* bracketend(uschar* cc)
402: {
403: SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
404: do cc += GET(cc, 1); while (*cc == OP_ALT);
405: SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
406: cc += 1 + LINK_SIZE;
407: return cc;
408: }
409:
410: /* Functions whose might need modification for all new supported opcodes:
411: next_opcode
412: get_localspace
413: set_localptrs
414: get_framesize
415: init_frame
416: get_localsize
417: copy_locals
418: compile_hotpath
419: compile_fallbackpath
420: */
421:
422: static uschar *next_opcode(compiler_common *common, uschar *cc)
423: {
424: SLJIT_UNUSED_ARG(common);
425: switch(*cc)
426: {
427: case OP_SOD:
428: case OP_SOM:
429: case OP_SET_SOM:
430: case OP_NOT_WORD_BOUNDARY:
431: case OP_WORD_BOUNDARY:
432: case OP_NOT_DIGIT:
433: case OP_DIGIT:
434: case OP_NOT_WHITESPACE:
435: case OP_WHITESPACE:
436: case OP_NOT_WORDCHAR:
437: case OP_WORDCHAR:
438: case OP_ANY:
439: case OP_ALLANY:
440: case OP_ANYNL:
441: case OP_NOT_HSPACE:
442: case OP_HSPACE:
443: case OP_NOT_VSPACE:
444: case OP_VSPACE:
445: case OP_EXTUNI:
446: case OP_EODN:
447: case OP_EOD:
448: case OP_CIRC:
449: case OP_CIRCM:
450: case OP_DOLL:
451: case OP_DOLLM:
452: case OP_TYPESTAR:
453: case OP_TYPEMINSTAR:
454: case OP_TYPEPLUS:
455: case OP_TYPEMINPLUS:
456: case OP_TYPEQUERY:
457: case OP_TYPEMINQUERY:
458: case OP_TYPEPOSSTAR:
459: case OP_TYPEPOSPLUS:
460: case OP_TYPEPOSQUERY:
461: case OP_CRSTAR:
462: case OP_CRMINSTAR:
463: case OP_CRPLUS:
464: case OP_CRMINPLUS:
465: case OP_CRQUERY:
466: case OP_CRMINQUERY:
467: case OP_DEF:
468: case OP_BRAZERO:
469: case OP_BRAMINZERO:
470: case OP_BRAPOSZERO:
471: case OP_FAIL:
472: case OP_ACCEPT:
473: case OP_ASSERT_ACCEPT:
474: case OP_SKIPZERO:
475: return cc + 1;
476:
477: case OP_ANYBYTE:
478: #ifdef SUPPORT_UTF8
479: if (common->utf8) return NULL;
480: #endif
481: return cc + 1;
482:
483: case OP_CHAR:
484: case OP_CHARI:
485: case OP_NOT:
486: case OP_NOTI:
487:
488: case OP_STAR:
489: case OP_MINSTAR:
490: case OP_PLUS:
491: case OP_MINPLUS:
492: case OP_QUERY:
493: case OP_MINQUERY:
494: case OP_POSSTAR:
495: case OP_POSPLUS:
496: case OP_POSQUERY:
497: case OP_STARI:
498: case OP_MINSTARI:
499: case OP_PLUSI:
500: case OP_MINPLUSI:
501: case OP_QUERYI:
502: case OP_MINQUERYI:
503: case OP_POSSTARI:
504: case OP_POSPLUSI:
505: case OP_POSQUERYI:
506: case OP_NOTSTAR:
507: case OP_NOTMINSTAR:
508: case OP_NOTPLUS:
509: case OP_NOTMINPLUS:
510: case OP_NOTQUERY:
511: case OP_NOTMINQUERY:
512: case OP_NOTPOSSTAR:
513: case OP_NOTPOSPLUS:
514: case OP_NOTPOSQUERY:
515: case OP_NOTSTARI:
516: case OP_NOTMINSTARI:
517: case OP_NOTPLUSI:
518: case OP_NOTMINPLUSI:
519: case OP_NOTQUERYI:
520: case OP_NOTMINQUERYI:
521: case OP_NOTPOSSTARI:
522: case OP_NOTPOSPLUSI:
523: case OP_NOTPOSQUERYI:
524: cc += 2;
525: #ifdef SUPPORT_UTF8
526: if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
527: #endif
528: return cc;
529:
530: case OP_UPTO:
531: case OP_MINUPTO:
532: case OP_EXACT:
533: case OP_POSUPTO:
534: case OP_UPTOI:
535: case OP_MINUPTOI:
536: case OP_EXACTI:
537: case OP_POSUPTOI:
538: case OP_NOTUPTO:
539: case OP_NOTMINUPTO:
540: case OP_NOTEXACT:
541: case OP_NOTPOSUPTO:
542: case OP_NOTUPTOI:
543: case OP_NOTMINUPTOI:
544: case OP_NOTEXACTI:
545: case OP_NOTPOSUPTOI:
546: cc += 4;
547: #ifdef SUPPORT_UTF8
548: if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
549: #endif
550: return cc;
551:
552: case OP_NOTPROP:
553: case OP_PROP:
554: case OP_TYPEUPTO:
555: case OP_TYPEMINUPTO:
556: case OP_TYPEEXACT:
557: case OP_TYPEPOSUPTO:
558: case OP_REF:
559: case OP_REFI:
560: case OP_CREF:
561: case OP_NCREF:
562: case OP_RREF:
563: case OP_NRREF:
564: case OP_CLOSE:
565: cc += 3;
566: return cc;
567:
568: case OP_CRRANGE:
569: case OP_CRMINRANGE:
570: return cc + 5;
571:
572: case OP_CLASS:
573: case OP_NCLASS:
574: return cc + 33;
575:
576: #ifdef SUPPORT_UTF8
577: case OP_XCLASS:
578: return cc + GET(cc, 1);
579: #endif
580:
581: case OP_RECURSE:
582: case OP_ASSERT:
583: case OP_ASSERT_NOT:
584: case OP_ASSERTBACK:
585: case OP_ASSERTBACK_NOT:
586: case OP_REVERSE:
587: case OP_ONCE:
588: case OP_ONCE_NC:
589: case OP_BRA:
590: case OP_BRAPOS:
591: case OP_COND:
592: case OP_SBRA:
593: case OP_SBRAPOS:
594: case OP_SCOND:
595: case OP_ALT:
596: case OP_KET:
597: case OP_KETRMAX:
598: case OP_KETRMIN:
599: case OP_KETRPOS:
600: return cc + 1 + LINK_SIZE;
601:
602: case OP_CBRA:
603: case OP_CBRAPOS:
604: case OP_SCBRA:
605: case OP_SCBRAPOS:
606: return cc + 1 + LINK_SIZE + 2;
607:
608: default:
609: return NULL;
610: }
611: }
612:
613: static int get_localspace(compiler_common *common, uschar *cc, uschar *ccend)
614: {
615: int localspace = 0;
616: uschar *alternative;
617: /* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
618: while (cc < ccend)
619: {
620: switch(*cc)
621: {
622: case OP_ASSERT:
623: case OP_ASSERT_NOT:
624: case OP_ASSERTBACK:
625: case OP_ASSERTBACK_NOT:
626: case OP_ONCE:
627: case OP_ONCE_NC:
628: case OP_BRAPOS:
629: case OP_SBRA:
630: case OP_SBRAPOS:
631: case OP_SCOND:
632: localspace += sizeof(sljit_w);
633: cc += 1 + LINK_SIZE;
634: break;
635:
636: case OP_CBRAPOS:
637: case OP_SCBRAPOS:
638: localspace += sizeof(sljit_w);
639: cc += 1 + LINK_SIZE + 2;
640: break;
641:
642: case OP_COND:
643: /* Might be a hidden SCOND. */
644: alternative = cc + GET(cc, 1);
645: if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
646: localspace += sizeof(sljit_w);
647: cc += 1 + LINK_SIZE;
648: break;
649:
650: default:
651: cc = next_opcode(common, cc);
652: if (cc == NULL)
653: return -1;
654: break;
655: }
656: }
657: return localspace;
658: }
659:
660: static void set_localptrs(compiler_common *common, int localptr, uschar *ccend)
661: {
662: uschar *cc = common->start;
663: uschar *alternative;
664: while (cc < ccend)
665: {
666: switch(*cc)
667: {
668: case OP_ASSERT:
669: case OP_ASSERT_NOT:
670: case OP_ASSERTBACK:
671: case OP_ASSERTBACK_NOT:
672: case OP_ONCE:
673: case OP_ONCE_NC:
674: case OP_BRAPOS:
675: case OP_SBRA:
676: case OP_SBRAPOS:
677: case OP_SCOND:
678: common->localptrs[cc - common->start] = localptr;
679: localptr += sizeof(sljit_w);
680: cc += 1 + LINK_SIZE;
681: break;
682:
683: case OP_CBRAPOS:
684: case OP_SCBRAPOS:
685: common->localptrs[cc - common->start] = localptr;
686: localptr += sizeof(sljit_w);
687: cc += 1 + LINK_SIZE + 2;
688: break;
689:
690: case OP_COND:
691: /* Might be a hidden SCOND. */
692: alternative = cc + GET(cc, 1);
693: if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
694: {
695: common->localptrs[cc - common->start] = localptr;
696: localptr += sizeof(sljit_w);
697: }
698: cc += 1 + LINK_SIZE;
699: break;
700:
701: default:
702: cc = next_opcode(common, cc);
703: SLJIT_ASSERT(cc != NULL);
704: break;
705: }
706: }
707: }
708:
709: /* Returns with -1 if no need for frame. */
710: static int get_framesize(compiler_common *common, uschar *cc, BOOL recursive)
711: {
712: uschar *ccend = bracketend(cc);
713: int length = 0;
714: BOOL possessive = FALSE;
715: BOOL setsom_found = FALSE;
716:
717: if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
718: {
719: length = 3;
720: possessive = TRUE;
721: }
722:
723: cc = next_opcode(common, cc);
724: SLJIT_ASSERT(cc != NULL);
725: while (cc < ccend)
726: switch(*cc)
727: {
728: case OP_SET_SOM:
729: case OP_RECURSE:
730: if (!setsom_found)
731: {
732: length += 2;
733: setsom_found = TRUE;
734: }
735: cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
736: break;
737:
738: case OP_CBRA:
739: case OP_CBRAPOS:
740: case OP_SCBRA:
741: case OP_SCBRAPOS:
742: length += 3;
743: cc += 1 + LINK_SIZE + 2;
744: break;
745:
746: default:
747: cc = next_opcode(common, cc);
748: SLJIT_ASSERT(cc != NULL);
749: break;
750: }
751:
752: /* Possessive quantifiers can use a special case. */
753: if (SLJIT_UNLIKELY(possessive) && length == 3)
754: return -1;
755:
756: if (length > 0)
757: return length + 1;
758: return -1;
759: }
760:
761: static void init_frame(compiler_common *common, uschar *cc, int stackpos, int stacktop, BOOL recursive)
762: {
763: DEFINE_COMPILER;
764: uschar *ccend = bracketend(cc);
765: BOOL setsom_found = FALSE;
766: int offset;
767:
768: /* >= 1 + shortest item size (2) */
769: SLJIT_ASSERT(stackpos >= stacktop + 2);
770:
771: stackpos = STACK(stackpos);
772: if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
773: cc = next_opcode(common, cc);
774: SLJIT_ASSERT(cc != NULL);
775: while (cc < ccend)
776: switch(*cc)
777: {
778: case OP_SET_SOM:
779: case OP_RECURSE:
780: if (!setsom_found)
781: {
782: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
783: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_setstrbegin);
784: stackpos += (int)sizeof(sljit_w);
785: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
786: stackpos += (int)sizeof(sljit_w);
787: setsom_found = TRUE;
788: }
789: cc += (*cc == OP_SET_SOM) ? 1 : 1 + LINK_SIZE;
790: break;
791:
792: case OP_CBRA:
793: case OP_CBRAPOS:
794: case OP_SCBRA:
795: case OP_SCBRAPOS:
796: offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
797: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
798: stackpos += (int)sizeof(sljit_w);
799: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
800: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
801: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
802: stackpos += (int)sizeof(sljit_w);
803: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);
804: stackpos += (int)sizeof(sljit_w);
805:
806: cc += 1 + LINK_SIZE + 2;
807: break;
808:
809: default:
810: cc = next_opcode(common, cc);
811: SLJIT_ASSERT(cc != NULL);
812: break;
813: }
814:
815: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, frame_end);
816: SLJIT_ASSERT(stackpos == STACK(stacktop));
817: }
818:
819: static SLJIT_INLINE int get_localsize(compiler_common *common, uschar *cc, uschar *ccend)
820: {
821: int localsize = 2;
822: uschar *alternative;
823: /* Calculate the sum of the local variables. */
824: while (cc < ccend)
825: {
826: switch(*cc)
827: {
828: case OP_ASSERT:
829: case OP_ASSERT_NOT:
830: case OP_ASSERTBACK:
831: case OP_ASSERTBACK_NOT:
832: case OP_ONCE:
833: case OP_ONCE_NC:
834: case OP_BRAPOS:
835: case OP_SBRA:
836: case OP_SBRAPOS:
837: case OP_SCOND:
838: localsize++;
839: cc += 1 + LINK_SIZE;
840: break;
841:
842: case OP_CBRA:
843: case OP_SCBRA:
844: localsize++;
845: cc += 1 + LINK_SIZE + 2;
846: break;
847:
848: case OP_CBRAPOS:
849: case OP_SCBRAPOS:
850: localsize += 2;
851: cc += 1 + LINK_SIZE + 2;
852: break;
853:
854: case OP_COND:
855: /* Might be a hidden SCOND. */
856: alternative = cc + GET(cc, 1);
857: if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
858: localsize++;
859: cc += 1 + LINK_SIZE;
860: break;
861:
862: default:
863: cc = next_opcode(common, cc);
864: SLJIT_ASSERT(cc != NULL);
865: break;
866: }
867: }
868: SLJIT_ASSERT(cc == ccend);
869: return localsize;
870: }
871:
872: static void copy_locals(compiler_common *common, uschar *cc, uschar *ccend,
873: BOOL save, int stackptr, int stacktop)
874: {
875: DEFINE_COMPILER;
876: int srcw[2];
877: int count;
878: BOOL tmp1next = TRUE;
879: BOOL tmp1empty = TRUE;
880: BOOL tmp2empty = TRUE;
881: uschar *alternative;
882: enum {
883: start,
884: loop,
885: end
886: } status;
887:
888: status = save ? start : loop;
889: stackptr = STACK(stackptr - 2);
890: stacktop = STACK(stacktop - 1);
891:
892: if (!save)
893: {
894: stackptr += sizeof(sljit_w);
895: if (stackptr < stacktop)
896: {
897: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
898: stackptr += sizeof(sljit_w);
899: tmp1empty = FALSE;
900: }
901: if (stackptr < stacktop)
902: {
903: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
904: stackptr += sizeof(sljit_w);
905: tmp2empty = FALSE;
906: }
907: /* The tmp1next must be TRUE in either way. */
908: }
909:
910: while (status != end)
911: {
912: count = 0;
913: switch(status)
914: {
915: case start:
916: SLJIT_ASSERT(save);
917: count = 1;
918: srcw[0] = RECURSIVE_HEAD;
919: status = loop;
920: break;
921:
922: case loop:
923: if (cc >= ccend)
924: {
925: status = end;
926: break;
927: }
928:
929: switch(*cc)
930: {
931: case OP_ASSERT:
932: case OP_ASSERT_NOT:
933: case OP_ASSERTBACK:
934: case OP_ASSERTBACK_NOT:
935: case OP_ONCE:
936: case OP_ONCE_NC:
937: case OP_BRAPOS:
938: case OP_SBRA:
939: case OP_SBRAPOS:
940: case OP_SCOND:
941: count = 1;
942: srcw[0] = PRIV(cc);
943: SLJIT_ASSERT(srcw[0] != 0);
944: cc += 1 + LINK_SIZE;
945: break;
946:
947: case OP_CBRA:
948: case OP_SCBRA:
949: count = 1;
950: srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
951: cc += 1 + LINK_SIZE + 2;
952: break;
953:
954: case OP_CBRAPOS:
955: case OP_SCBRAPOS:
956: count = 2;
957: srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
958: srcw[0] = PRIV(cc);
959: SLJIT_ASSERT(srcw[0] != 0);
960: cc += 1 + LINK_SIZE + 2;
961: break;
962:
963: case OP_COND:
964: /* Might be a hidden SCOND. */
965: alternative = cc + GET(cc, 1);
966: if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
967: {
968: count = 1;
969: srcw[0] = PRIV(cc);
970: SLJIT_ASSERT(srcw[0] != 0);
971: }
972: cc += 1 + LINK_SIZE;
973: break;
974:
975: default:
976: cc = next_opcode(common, cc);
977: SLJIT_ASSERT(cc != NULL);
978: break;
979: }
980: break;
981:
982: case end:
983: SLJIT_ASSERT_STOP();
984: break;
985: }
986:
987: while (count > 0)
988: {
989: count--;
990: if (save)
991: {
992: if (tmp1next)
993: {
994: if (!tmp1empty)
995: {
996: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
997: stackptr += sizeof(sljit_w);
998: }
999: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);
1000: tmp1empty = FALSE;
1001: tmp1next = FALSE;
1002: }
1003: else
1004: {
1005: if (!tmp2empty)
1006: {
1007: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
1008: stackptr += sizeof(sljit_w);
1009: }
1010: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);
1011: tmp2empty = FALSE;
1012: tmp1next = TRUE;
1013: }
1014: }
1015: else
1016: {
1017: if (tmp1next)
1018: {
1019: SLJIT_ASSERT(!tmp1empty);
1020: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP1, 0);
1021: tmp1empty = stackptr >= stacktop;
1022: if (!tmp1empty)
1023: {
1024: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
1025: stackptr += sizeof(sljit_w);
1026: }
1027: tmp1next = FALSE;
1028: }
1029: else
1030: {
1031: SLJIT_ASSERT(!tmp2empty);
1032: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP2, 0);
1033: tmp2empty = stackptr >= stacktop;
1034: if (!tmp2empty)
1035: {
1036: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
1037: stackptr += sizeof(sljit_w);
1038: }
1039: tmp1next = TRUE;
1040: }
1041: }
1042: }
1043: }
1044:
1045: if (save)
1046: {
1047: if (tmp1next)
1048: {
1049: if (!tmp1empty)
1050: {
1051: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
1052: stackptr += sizeof(sljit_w);
1053: }
1054: if (!tmp2empty)
1055: {
1056: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
1057: stackptr += sizeof(sljit_w);
1058: }
1059: }
1060: else
1061: {
1062: if (!tmp2empty)
1063: {
1064: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
1065: stackptr += sizeof(sljit_w);
1066: }
1067: if (!tmp1empty)
1068: {
1069: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
1070: stackptr += sizeof(sljit_w);
1071: }
1072: }
1073: }
1074: SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
1075: }
1076:
1077: static SLJIT_INLINE BOOL ispowerof2(unsigned int value)
1078: {
1079: return (value & (value - 1)) == 0;
1080: }
1081:
1082: static SLJIT_INLINE void set_jumps(jump_list *list, struct sljit_label *label)
1083: {
1084: while (list)
1085: {
1086: /* sljit_set_label is clever enough to do nothing
1087: if either the jump or the label is NULL */
1088: sljit_set_label(list->jump, label);
1089: list = list->next;
1090: }
1091: }
1092:
1093: static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump* jump)
1094: {
1095: jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));
1096: if (list_item)
1097: {
1098: list_item->next = *list;
1099: list_item->jump = jump;
1100: *list = list_item;
1101: }
1102: }
1103:
1104: static void add_stub(compiler_common *common, enum stub_types type, int data, struct sljit_jump *start)
1105: {
1106: DEFINE_COMPILER;
1107: stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
1108:
1109: if (list_item)
1110: {
1111: list_item->type = type;
1112: list_item->data = data;
1113: list_item->start = start;
1114: list_item->leave = LABEL();
1115: list_item->next = common->stubs;
1116: common->stubs = list_item;
1117: }
1118: }
1119:
1120: static void flush_stubs(compiler_common *common)
1121: {
1122: DEFINE_COMPILER;
1123: stub_list* list_item = common->stubs;
1124:
1125: while (list_item)
1126: {
1127: JUMPHERE(list_item->start);
1128: switch(list_item->type)
1129: {
1130: case stack_alloc:
1131: add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
1132: break;
1133: }
1134: JUMPTO(SLJIT_JUMP, list_item->leave);
1135: list_item = list_item->next;
1136: }
1137: common->stubs = NULL;
1138: }
1139:
1140: static SLJIT_INLINE void decrease_call_count(compiler_common *common)
1141: {
1142: DEFINE_COMPILER;
1143:
1144: OP2(SLJIT_SUB | SLJIT_SET_E, CALL_COUNT, 0, CALL_COUNT, 0, SLJIT_IMM, 1);
1145: add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));
1146: }
1147:
1148: static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)
1149: {
1150: /* May destroy all locals and registers except TMP2. */
1151: DEFINE_COMPILER;
1152:
1153: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_w));
1154: #ifdef DESTROY_REGISTERS
1155: OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);
1156: OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
1157: OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
1158: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);
1159: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);
1160: #endif
1161: add_stub(common, stack_alloc, 0, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));
1162: }
1163:
1164: static SLJIT_INLINE void free_stack(compiler_common *common, int size)
1165: {
1166: DEFINE_COMPILER;
1167: OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_w));
1168: }
1169:
1170: static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)
1171: {
1172: DEFINE_COMPILER;
1173: struct sljit_label *loop;
1174: int i;
1175: /* At this point we can freely use all temporary registers. */
1176: /* TMP1 returns with begin - 1. */
1177: OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, 1);
1178: if (length < 8)
1179: {
1180: for (i = 0; i < length; i++)
1181: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_TEMPORARY_REG1, 0);
1182: }
1183: else
1184: {
1185: OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START - sizeof(sljit_w));
1186: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, length);
1187: loop = LABEL();
1188: OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), sizeof(sljit_w), SLJIT_TEMPORARY_REG1, 0);
1189: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG3, 0, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, 1);
1190: JUMPTO(SLJIT_C_NOT_ZERO, loop);
1191: }
1192: }
1193:
1194: static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
1195: {
1196: DEFINE_COMPILER;
1197: struct sljit_label *loop;
1198: struct sljit_jump *earlyexit;
1199:
1200: /* At this point we can freely use all registers. */
1201: OP1(SLJIT_MOV, SLJIT_GENERAL_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
1202: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);
1203:
1204: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, ARGUMENTS, 0);
1205: OP1(SLJIT_MOV_SI, SLJIT_TEMPORARY_REG2, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsetcount));
1206: OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
1207: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), SLJIT_OFFSETOF(jit_arguments, begin));
1208: OP2(SLJIT_ADD, SLJIT_GENERAL_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START);
1209: /* Unlikely, but possible */
1210: earlyexit = CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 0);
1211: loop = LABEL();
1212: OP2(SLJIT_SUB, SLJIT_GENERAL_REG2, 0, SLJIT_MEM1(SLJIT_GENERAL_REG1), 0, SLJIT_TEMPORARY_REG1, 0);
1213: OP2(SLJIT_ADD, SLJIT_GENERAL_REG1, 0, SLJIT_GENERAL_REG1, 0, SLJIT_IMM, sizeof(sljit_w));
1214: /* Copy the integer value to the output buffer */
1215: OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_TEMPORARY_REG3), sizeof(int), SLJIT_GENERAL_REG2, 0);
1216: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
1217: JUMPTO(SLJIT_C_NOT_ZERO, loop);
1218: JUMPHERE(earlyexit);
1219:
1220: /* Calculate the return value, which is the maximum ovector value. */
1221: if (topbracket > 1)
1222: {
1223: OP2(SLJIT_ADD, SLJIT_TEMPORARY_REG1, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, OVECTOR_START + topbracket * 2 * sizeof(sljit_w));
1224: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, topbracket + 1);
1225:
1226: /* OVECTOR(0) is never equal to SLJIT_GENERAL_REG3. */
1227: loop = LABEL();
1228: OP1(SLJIT_MOVU, SLJIT_TEMPORARY_REG3, 0, SLJIT_MEM1(SLJIT_TEMPORARY_REG1), -(2 * (sljit_w)sizeof(sljit_w)));
1229: OP2(SLJIT_SUB, SLJIT_TEMPORARY_REG2, 0, SLJIT_TEMPORARY_REG2, 0, SLJIT_IMM, 1);
1230: CMPTO(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG3, 0, SLJIT_GENERAL_REG3, 0, loop);
1231: OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_TEMPORARY_REG2, 0);
1232: }
1233: else
1234: OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
1235: }
1236:
1237: static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, uschar* cc)
1238: {
1239: /* Detects if the character has an othercase. */
1240: unsigned int c;
1241:
1242: #ifdef SUPPORT_UTF8
1243: if (common->utf8)
1244: {
1245: GETCHAR(c, cc);
1246: if (c > 127)
1247: {
1248: #ifdef SUPPORT_UCP
1249: return c != UCD_OTHERCASE(c);
1250: #else
1251: return FALSE;
1252: #endif
1253: }
1254: }
1255: else
1256: #endif
1257: c = *cc;
1258: return common->fcc[c] != c;
1259: }
1260:
1261: static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c)
1262: {
1263: /* Returns with the othercase. */
1264: #ifdef SUPPORT_UTF8
1265: if (common->utf8 && c > 127)
1266: {
1267: #ifdef SUPPORT_UCP
1268: return UCD_OTHERCASE(c);
1269: #else
1270: return c;
1271: #endif
1272: }
1273: #endif
1274: return common->fcc[c];
1275: }
1276:
1277: static unsigned int char_get_othercase_bit(compiler_common *common, uschar* cc)
1278: {
1279: /* Detects if the character and its othercase has only 1 bit difference. */
1280: unsigned int c, oc, bit;
1281: #ifdef SUPPORT_UTF8
1282: int n;
1283: #endif
1284:
1285: #ifdef SUPPORT_UTF8
1286: if (common->utf8)
1287: {
1288: GETCHAR(c, cc);
1289: if (c <= 127)
1290: oc = common->fcc[c];
1291: else
1292: {
1293: #ifdef SUPPORT_UCP
1294: oc = UCD_OTHERCASE(c);
1295: #else
1296: oc = c;
1297: #endif
1298: }
1299: }
1300: else
1301: {
1302: c = *cc;
1303: oc = common->fcc[c];
1304: }
1305: #else
1306: c = *cc;
1307: oc = common->fcc[c];
1308: #endif
1309:
1310: SLJIT_ASSERT(c != oc);
1311:
1312: bit = c ^ oc;
1313: /* Optimized for English alphabet. */
1314: if (c <= 127 && bit == 0x20)
1315: return (0 << 8) | 0x20;
1316:
1317: /* Since c != oc, they must have at least 1 bit difference. */
1318: if (!ispowerof2(bit))
1319: return 0;
1320:
1321: #ifdef SUPPORT_UTF8
1322: if (common->utf8 && c > 127)
1323: {
1324: n = _pcre_utf8_table4[*cc & 0x3f];
1325: while ((bit & 0x3f) == 0)
1326: {
1327: n--;
1328: bit >>= 6;
1329: }
1330: return (n << 8) | bit;
1331: }
1332: #endif
1333: return (0 << 8) | bit;
1334: }
1335:
1336: static SLJIT_INLINE void check_input_end(compiler_common *common, jump_list **fallbacks)
1337: {
1338: DEFINE_COMPILER;
1339: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
1340: }
1341:
1342: static void read_char(compiler_common *common)
1343: {
1344: /* Reads the character into TMP1, updates STR_PTR.
1345: Does not check STR_END. TMP2 Destroyed. */
1346: DEFINE_COMPILER;
1347: #ifdef SUPPORT_UTF8
1348: struct sljit_jump *jump;
1349: #endif
1350:
1351: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1352: #ifdef SUPPORT_UTF8
1353: if (common->utf8)
1354: {
1355: jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
1356: add_jump(compiler, &common->utf8readchar, JUMP(SLJIT_FAST_CALL));
1357: JUMPHERE(jump);
1358: }
1359: #endif
1360: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1361: }
1362:
1363: static void peek_char(compiler_common *common)
1364: {
1365: /* Reads the character into TMP1, keeps STR_PTR.
1366: Does not check STR_END. TMP2 Destroyed. */
1367: DEFINE_COMPILER;
1368: #ifdef SUPPORT_UTF8
1369: struct sljit_jump *jump;
1370: #endif
1371:
1372: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1373: #ifdef SUPPORT_UTF8
1374: if (common->utf8)
1375: {
1376: jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
1377: add_jump(compiler, &common->utf8readchar, JUMP(SLJIT_FAST_CALL));
1378: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
1379: JUMPHERE(jump);
1380: }
1381: #endif
1382: }
1383:
1384: static void read_char8_type(compiler_common *common)
1385: {
1386: /* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
1387: DEFINE_COMPILER;
1388: #ifdef SUPPORT_UTF8
1389: struct sljit_jump *jump;
1390: #endif
1391:
1392: #ifdef SUPPORT_UTF8
1393: if (common->utf8)
1394: {
1395: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
1396: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1397: /* This can be an extra read in some situations, but hopefully
1398: it is a clever early read in most cases. */
1399: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
1400: jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
1401: add_jump(compiler, &common->utf8readtype8, JUMP(SLJIT_FAST_CALL));
1402: JUMPHERE(jump);
1403: return;
1404: }
1405: #endif
1406: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1407: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1408: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
1409: }
1410:
1411: static void skip_char_back(compiler_common *common)
1412: {
1413: /* Goes one character back. Only affects STR_PTR. Does not check begin. */
1414: DEFINE_COMPILER;
1415: #ifdef SUPPORT_UTF8
1416: struct sljit_label *label;
1417:
1418: if (common->utf8)
1419: {
1420: label = LABEL();
1421: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1422: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1423: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
1424: CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
1425: return;
1426: }
1427: #endif
1428: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1429: }
1430:
1431: static void check_newlinechar(compiler_common *common, int nltype, jump_list **fallbacks, BOOL jumpiftrue)
1432: {
1433: /* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */
1434: DEFINE_COMPILER;
1435:
1436: if (nltype == NLTYPE_ANY)
1437: {
1438: add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
1439: add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
1440: }
1441: else if (nltype == NLTYPE_ANYCRLF)
1442: {
1443: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);
1444: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
1445: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
1446: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
1447: add_jump(compiler, fallbacks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
1448: }
1449: else
1450: {
1451: SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline <= 255);
1452: add_jump(compiler, fallbacks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
1453: }
1454: }
1455:
1456: #ifdef SUPPORT_UTF8
1457: static void do_utf8readchar(compiler_common *common)
1458: {
1459: /* Fast decoding an utf8 character. TMP1 contains the first byte
1460: of the character (>= 0xc0). Return char value in TMP1, length - 1 in TMP2. */
1461: DEFINE_COMPILER;
1462: struct sljit_jump *jump;
1463:
1464: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
1465: /* Searching for the first zero. */
1466: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
1467: jump = JUMP(SLJIT_C_NOT_ZERO);
1468: /* 2 byte sequence */
1469: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
1470: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1471: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1f);
1472: OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
1473: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1474: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1475: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
1476: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1477: JUMPHERE(jump);
1478:
1479: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10);
1480: jump = JUMP(SLJIT_C_NOT_ZERO);
1481: /* 3 byte sequence */
1482: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
1483: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f);
1484: OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);
1485: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1486: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
1487: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1488: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
1489: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 2);
1490: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1491: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1492: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 2);
1493: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1494: JUMPHERE(jump);
1495:
1496: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x08);
1497: jump = JUMP(SLJIT_C_NOT_ZERO);
1498: /* 4 byte sequence */
1499: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
1500: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07);
1501: OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18);
1502: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1503: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);
1504: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1505: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
1506: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1507: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
1508: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1509: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 3);
1510: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 3);
1511: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1512: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1513: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 3);
1514: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1515: JUMPHERE(jump);
1516:
1517: /* 5 byte sequence */
1518: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
1519: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x03);
1520: OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 24);
1521: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1522: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 18);
1523: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1524: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 2);
1525: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1526: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);
1527: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1528: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 3);
1529: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1530: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
1531: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1532: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 4);
1533: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 4);
1534: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
1535: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
1536: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 4);
1537: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1538: }
1539:
1540: static void do_utf8readtype8(compiler_common *common)
1541: {
1542: /* Fast decoding an utf8 character type. TMP2 contains the first byte
1543: of the character (>= 0xc0) and TMP1 is destroyed. Return value in TMP1. */
1544: DEFINE_COMPILER;
1545: struct sljit_jump *jump;
1546: struct sljit_jump *compare;
1547:
1548: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
1549:
1550: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
1551: jump = JUMP(SLJIT_C_NOT_ZERO);
1552: /* 2 byte sequence */
1553: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1554: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1555: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
1556: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
1557: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
1558: OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
1559: compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);
1560: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
1561: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1562:
1563: JUMPHERE(compare);
1564: OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
1565: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1566: JUMPHERE(jump);
1567:
1568: /* We only have types for characters less than 256. */
1569: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_w)_pcre_utf8_char_sizes - 0xc0);
1570: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
1571: OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
1572: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1573: }
1574:
1575: #endif
1576:
1577: #ifdef SUPPORT_UCP
1578:
1579: /* UCD_BLOCK_SIZE must be 128 (see the assert below). */
1580: #define UCD_BLOCK_MASK 127
1581: #define UCD_BLOCK_SHIFT 7
1582:
1583: static void do_getucd(compiler_common *common)
1584: {
1585: /* Search the UCD record for the character comes in TMP1.
1586: Returns chartype in TMP1 and UCD offset in TMP2. */
1587: DEFINE_COMPILER;
1588:
1589: SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);
1590:
1591: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
1592: OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
1593: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_w)_pcre_ucd_stage1);
1594: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
1595: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
1596: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
1597: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_stage2);
1598: OP1(SLJIT_MOV_UH, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
1599: OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_records + SLJIT_OFFSETOF(ucd_record, chartype));
1600: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
1601: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1602: }
1603: #endif
1604:
1605: static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf, BOOL firstline)
1606: {
1607: DEFINE_COMPILER;
1608: struct sljit_label *mainloop;
1609: struct sljit_label *newlinelabel = NULL;
1610: struct sljit_jump *start;
1611: struct sljit_jump *end = NULL;
1612: struct sljit_jump *nl = NULL;
1613: #ifdef SUPPORT_UTF8
1614: struct sljit_jump *singlebyte;
1615: #endif
1616: jump_list *newline = NULL;
1617: BOOL newlinecheck = FALSE;
1618: BOOL readbyte = FALSE;
1619:
1620: if (!(hascrorlf || firstline) && (common->nltype == NLTYPE_ANY ||
1621: common->nltype == NLTYPE_ANYCRLF || common->newline > 255))
1622: newlinecheck = TRUE;
1623:
1624: if (firstline)
1625: {
1626: /* Search for the end of the first line. */
1627: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STR_PTR, 0);
1628: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_END, 0);
1629:
1630: if (common->nltype == NLTYPE_FIXED && common->newline > 255)
1631: {
1632: mainloop = LABEL();
1633: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1634: end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1635: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -1);
1636: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
1637: CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
1638: CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
1639: OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0, SLJIT_IMM, 1);
1640: }
1641: else
1642: {
1643: end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1644: mainloop = LABEL();
1645: /* Continual stores does not cause data dependency. */
1646: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);
1647: read_char(common);
1648: check_newlinechar(common, common->nltype, &newline, TRUE);
1649: CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
1650: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, STR_PTR, 0);
1651: set_jumps(newline, LABEL());
1652: }
1653:
1654: JUMPHERE(end);
1655: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
1656: }
1657:
1658: start = JUMP(SLJIT_JUMP);
1659:
1660: if (newlinecheck)
1661: {
1662: newlinelabel = LABEL();
1663: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1664: end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1665: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1666: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);
1667: COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
1668: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
1669: nl = JUMP(SLJIT_JUMP);
1670: }
1671:
1672: mainloop = LABEL();
1673:
1674: /* Increasing the STR_PTR here requires one less jump in the most common case. */
1675: #ifdef SUPPORT_UTF8
1676: if (common->utf8) readbyte = TRUE;
1677: #endif
1678: if (newlinecheck) readbyte = TRUE;
1679:
1680: if (readbyte)
1681: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1682:
1683: if (newlinecheck)
1684: CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
1685:
1686: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1687: #ifdef SUPPORT_UTF8
1688: if (common->utf8)
1689: {
1690: singlebyte = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
1691: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes - 0xc0);
1692: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
1693: JUMPHERE(singlebyte);
1694: }
1695: #endif
1696: JUMPHERE(start);
1697:
1698: if (newlinecheck)
1699: {
1700: JUMPHERE(end);
1701: JUMPHERE(nl);
1702: }
1703:
1704: return mainloop;
1705: }
1706:
1707: static SLJIT_INLINE void fast_forward_first_byte(compiler_common *common, pcre_uint16 firstbyte, BOOL firstline)
1708: {
1709: DEFINE_COMPILER;
1710: struct sljit_label *start;
1711: struct sljit_jump *leave;
1712: struct sljit_jump *found;
1713: pcre_uint16 oc, bit;
1714:
1715: if (firstline)
1716: {
1717: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
1718: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
1719: }
1720:
1721: start = LABEL();
1722: leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1723: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1724:
1725: if ((firstbyte & REQ_CASELESS) == 0)
1726: found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, firstbyte & 0xff);
1727: else
1728: {
1729: firstbyte &= 0xff;
1730: oc = common->fcc[firstbyte];
1731: bit = firstbyte ^ oc;
1732: if (ispowerof2(bit))
1733: {
1734: OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);
1735: found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, firstbyte | bit);
1736: }
1737: else
1738: {
1739: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, firstbyte);
1740: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
1741: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);
1742: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
1743: found = JUMP(SLJIT_C_NOT_ZERO);
1744: }
1745: }
1746:
1747: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1748: #ifdef SUPPORT_UTF8
1749: if (common->utf8)
1750: {
1751: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
1752: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes - 0xc0);
1753: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
1754: }
1755: #endif
1756: JUMPTO(SLJIT_JUMP, start);
1757: JUMPHERE(found);
1758: JUMPHERE(leave);
1759:
1760: if (firstline)
1761: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
1762: }
1763:
1764: static SLJIT_INLINE void fast_forward_newline(compiler_common *common, BOOL firstline)
1765: {
1766: DEFINE_COMPILER;
1767: struct sljit_label *loop;
1768: struct sljit_jump *lastchar;
1769: struct sljit_jump *firstchar;
1770: struct sljit_jump *leave;
1771: struct sljit_jump *foundcr = NULL;
1772: struct sljit_jump *notfoundnl;
1773: jump_list *newline = NULL;
1774:
1775: if (firstline)
1776: {
1777: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
1778: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
1779: }
1780:
1781: if (common->nltype == NLTYPE_FIXED && common->newline > 255)
1782: {
1783: lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1784: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
1785: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
1786: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
1787: firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
1788:
1789: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2);
1790: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
1791: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER_EQUAL);
1792: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
1793:
1794: loop = LABEL();
1795: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1796: leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1797: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -2);
1798: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), -1);
1799: CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);
1800: CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
1801:
1802: JUMPHERE(leave);
1803: JUMPHERE(firstchar);
1804: JUMPHERE(lastchar);
1805:
1806: if (firstline)
1807: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
1808: return;
1809: }
1810:
1811: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
1812: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
1813: firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
1814: skip_char_back(common);
1815:
1816: loop = LABEL();
1817: read_char(common);
1818: lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1819: if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
1820: foundcr = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
1821: check_newlinechar(common, common->nltype, &newline, FALSE);
1822: set_jumps(newline, loop);
1823:
1824: if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
1825: {
1826: leave = JUMP(SLJIT_JUMP);
1827: JUMPHERE(foundcr);
1828: notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1829: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1830: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
1831: COND_VALUE(SLJIT_MOV, TMP1, 0, SLJIT_C_EQUAL);
1832: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
1833: JUMPHERE(notfoundnl);
1834: JUMPHERE(leave);
1835: }
1836: JUMPHERE(lastchar);
1837: JUMPHERE(firstchar);
1838:
1839: if (firstline)
1840: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
1841: }
1842:
1843: static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)
1844: {
1845: DEFINE_COMPILER;
1846: struct sljit_label *start;
1847: struct sljit_jump *leave;
1848: struct sljit_jump *found;
1849:
1850: if (firstline)
1851: {
1852: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, STR_END, 0);
1853: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
1854: }
1855:
1856: start = LABEL();
1857: leave = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
1858: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
1859: #ifdef SUPPORT_UTF8
1860: if (common->utf8)
1861: OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
1862: #endif
1863: OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
1864: OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
1865: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), start_bits);
1866: OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
1867: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
1868: found = JUMP(SLJIT_C_NOT_ZERO);
1869:
1870: #ifdef SUPPORT_UTF8
1871: if (common->utf8)
1872: OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
1873: #endif
1874: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
1875: #ifdef SUPPORT_UTF8
1876: if (common->utf8)
1877: {
1878: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
1879: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes - 0xc0);
1880: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
1881: }
1882: #endif
1883: JUMPTO(SLJIT_JUMP, start);
1884: JUMPHERE(found);
1885: JUMPHERE(leave);
1886:
1887: if (firstline)
1888: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
1889: }
1890:
1891: static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uint16 reqbyte, BOOL has_firstbyte)
1892: {
1893: DEFINE_COMPILER;
1894: struct sljit_label *loop;
1895: struct sljit_jump *toolong;
1896: struct sljit_jump *alreadyfound;
1897: struct sljit_jump *found;
1898: struct sljit_jump *foundoc = NULL;
1899: struct sljit_jump *notfound;
1900: pcre_uint16 oc, bit;
1901:
1902: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_BYTE_PTR);
1903: OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);
1904: toolong = CMP(SLJIT_C_LESS, TMP1, 0, STR_END, 0);
1905: alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);
1906:
1907: if (has_firstbyte)
1908: OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, 1);
1909: else
1910: OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);
1911:
1912: loop = LABEL();
1913: notfound = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, STR_END, 0);
1914:
1915: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), 0);
1916: if ((reqbyte & REQ_CASELESS) == 0)
1917: found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, reqbyte & 0xff);
1918: else
1919: {
1920: reqbyte &= 0xff;
1921: oc = common->fcc[reqbyte];
1922: bit = reqbyte ^ oc;
1923: if (ispowerof2(bit))
1924: {
1925: OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
1926: found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, reqbyte | bit);
1927: }
1928: else
1929: {
1930: found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, reqbyte);
1931: foundoc = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, oc);
1932: }
1933: }
1934: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
1935: JUMPTO(SLJIT_JUMP, loop);
1936:
1937: JUMPHERE(found);
1938: if (foundoc)
1939: JUMPHERE(foundoc);
1940: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_BYTE_PTR, TMP1, 0);
1941: JUMPHERE(alreadyfound);
1942: JUMPHERE(toolong);
1943: return notfound;
1944: }
1945:
1946: static void do_revertframes(compiler_common *common)
1947: {
1948: DEFINE_COMPILER;
1949: struct sljit_jump *jump;
1950: struct sljit_label *mainloop;
1951:
1952: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
1953: OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0);
1954:
1955: /* Drop frames until we reach STACK_TOP. */
1956: mainloop = LABEL();
1957: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);
1958: jump = CMP(SLJIT_C_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
1959: OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_LOCALS_REG, 0);
1960: OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
1961: OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_w), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_w));
1962: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_w));
1963: JUMPTO(SLJIT_JUMP, mainloop);
1964:
1965: JUMPHERE(jump);
1966: jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_end);
1967: /* End of dropping frames. */
1968: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
1969:
1970: JUMPHERE(jump);
1971: jump = CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, frame_setstrbegin);
1972: /* Set string begin. */
1973: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), sizeof(sljit_w));
1974: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
1975: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);
1976: JUMPTO(SLJIT_JUMP, mainloop);
1977:
1978: JUMPHERE(jump);
1979: /* Unknown command. */
1980: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_w));
1981: JUMPTO(SLJIT_JUMP, mainloop);
1982: }
1983:
1984: static void check_wordboundary(compiler_common *common)
1985: {
1986: DEFINE_COMPILER;
1987: struct sljit_jump *beginend;
1988: #ifdef SUPPORT_UTF8
1989: struct sljit_jump *jump;
1990: #endif
1991:
1992: SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
1993:
1994: sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, 1, 5, 5, common->localsize);
1995: /* Get type of the previous char, and put it to LOCALS1. */
1996: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
1997: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
1998: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, 0);
1999: beginend = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
2000: skip_char_back(common);
2001: read_char(common);
2002:
2003: /* Testing char type. */
2004: #ifdef SUPPORT_UCP
2005: if (common->useucp)
2006: {
2007: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
2008: jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
2009: add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
2010: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
2011: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
2012: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
2013: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
2014: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
2015: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
2016: JUMPHERE(jump);
2017: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);
2018: }
2019: else
2020: #endif
2021: {
2022: #ifdef SUPPORT_UTF8
2023: /* Here LOCALS1 has already been zeroed. */
2024: jump = NULL;
2025: if (common->utf8)
2026: jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
2027: #endif
2028: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
2029: OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);
2030: OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
2031: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);
2032: #ifdef SUPPORT_UTF8
2033: if (jump != NULL)
2034: JUMPHERE(jump);
2035: #endif
2036: }
2037: JUMPHERE(beginend);
2038:
2039: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
2040: beginend = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
2041: peek_char(common);
2042:
2043: /* Testing char type. This is a code duplication. */
2044: #ifdef SUPPORT_UCP
2045: if (common->useucp)
2046: {
2047: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
2048: jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
2049: add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
2050: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
2051: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
2052: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
2053: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
2054: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
2055: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
2056: JUMPHERE(jump);
2057: }
2058: else
2059: #endif
2060: {
2061: #ifdef SUPPORT_UTF8
2062: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
2063: jump = NULL;
2064: if (common->utf8)
2065: jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
2066: #endif
2067: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);
2068: OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);
2069: OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
2070: #ifdef SUPPORT_UTF8
2071: if (jump != NULL)
2072: JUMPHERE(jump);
2073: #endif
2074: }
2075: JUMPHERE(beginend);
2076:
2077: OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
2078: sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
2079: }
2080:
2081: static void check_anynewline(compiler_common *common)
2082: {
2083: /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
2084: DEFINE_COMPILER;
2085:
2086: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
2087:
2088: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
2089: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
2090: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
2091: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
2092: #ifdef SUPPORT_UTF8
2093: if (common->utf8)
2094: {
2095: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2096: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
2097: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
2098: }
2099: #endif
2100: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
2101: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2102: }
2103:
2104: static void check_hspace(compiler_common *common)
2105: {
2106: /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
2107: DEFINE_COMPILER;
2108:
2109: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
2110:
2111: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);
2112: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
2113: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
2114: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2115: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);
2116: #ifdef SUPPORT_UTF8
2117: if (common->utf8)
2118: {
2119: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2120: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);
2121: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2122: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);
2123: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2124: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);
2125: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);
2126: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
2127: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);
2128: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2129: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);
2130: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2131: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);
2132: }
2133: #endif
2134: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
2135:
2136: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2137: }
2138:
2139: static void check_vspace(compiler_common *common)
2140: {
2141: /* Check whether TMP1 contains a newline character. TMP2 destroyed. */
2142: DEFINE_COMPILER;
2143:
2144: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
2145:
2146: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
2147: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
2148: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
2149: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
2150: #ifdef SUPPORT_UTF8
2151: if (common->utf8)
2152: {
2153: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
2154: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
2155: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
2156: }
2157: #endif
2158: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
2159:
2160: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2161: }
2162:
2163: #define CHAR1 STR_END
2164: #define CHAR2 STACK_TOP
2165:
2166: static void do_casefulcmp(compiler_common *common)
2167: {
2168: DEFINE_COMPILER;
2169: struct sljit_jump *jump;
2170: struct sljit_label *label;
2171:
2172: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
2173: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2174: OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);
2175: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR2, 0);
2176: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
2177: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2178:
2179: label = LABEL();
2180: OP1(SLJIT_MOVU_UB, CHAR1, 0, SLJIT_MEM1(TMP1), 1);
2181: OP1(SLJIT_MOVU_UB, CHAR2, 0, SLJIT_MEM1(STR_PTR), 1);
2182: jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
2183: OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
2184: JUMPTO(SLJIT_C_NOT_ZERO, label);
2185:
2186: JUMPHERE(jump);
2187: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2188: OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0);
2189: OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
2190: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2191: }
2192:
2193: #define LCC_TABLE STACK_LIMIT
2194:
2195: static void do_caselesscmp(compiler_common *common)
2196: {
2197: DEFINE_COMPILER;
2198: struct sljit_jump *jump;
2199: struct sljit_label *label;
2200:
2201: sljit_emit_fast_enter(compiler, RETURN_ADDR, 0, 1, 5, 5, common->localsize);
2202: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
2203:
2204: OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);
2205: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR1, 0);
2206: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, CHAR2, 0);
2207: OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc);
2208: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
2209: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2210:
2211: label = LABEL();
2212: OP1(SLJIT_MOVU_UB, CHAR1, 0, SLJIT_MEM1(TMP1), 1);
2213: OP1(SLJIT_MOVU_UB, CHAR2, 0, SLJIT_MEM1(STR_PTR), 1);
2214: OP1(SLJIT_MOV_UB, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0);
2215: OP1(SLJIT_MOV_UB, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0);
2216: jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);
2217: OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
2218: JUMPTO(SLJIT_C_NOT_ZERO, label);
2219:
2220: JUMPHERE(jump);
2221: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2222: OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0);
2223: OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
2224: OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
2225: sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
2226: }
2227:
2228: #undef LCC_TABLE
2229: #undef CHAR1
2230: #undef CHAR2
2231:
2232: #ifdef SUPPORT_UTF8
2233: #ifdef SUPPORT_UCP
2234:
2235: static uschar * SLJIT_CALL do_utf8caselesscmp(uschar *src1, jit_arguments *args, uschar *end1)
2236: {
2237: /* This function would be ineffective to do in JIT level. */
2238: int c1, c2;
2239: uschar *src2 = args->ptr;
2240: uschar *end2 = (uschar*)args->end;
2241:
2242: while (src1 < end1)
2243: {
2244: if (src2 >= end2)
2245: return 0;
2246: GETCHARINC(c1, src1);
2247: GETCHARINC(c2, src2);
2248: if (c1 != c2 && c1 != UCD_OTHERCASE(c2)) return 0;
2249: }
2250: return src2;
2251: }
2252:
2253: #endif
2254: #endif
2255:
2256: static uschar *byte_sequence_compare(compiler_common *common, BOOL caseless, uschar *cc,
2257: compare_context* context, jump_list **fallbacks)
2258: {
2259: DEFINE_COMPILER;
2260: unsigned int othercasebit = 0;
2261: uschar *othercasebyte = NULL;
2262: #ifdef SUPPORT_UTF8
2263: int utf8length;
2264: #endif
2265:
2266: if (caseless && char_has_othercase(common, cc))
2267: {
2268: othercasebit = char_get_othercase_bit(common, cc);
2269: SLJIT_ASSERT(othercasebit);
2270: /* Extracting bit difference info. */
2271: othercasebyte = cc + (othercasebit >> 8);
2272: othercasebit &= 0xff;
2273: }
2274:
2275: if (context->sourcereg == -1)
2276: {
2277: #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
2278: if (context->length >= 4)
2279: OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
2280: else if (context->length >= 2)
2281: OP1(SLJIT_MOV_SH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
2282: else
2283: #endif
2284: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
2285: context->sourcereg = TMP2;
2286: }
2287:
2288: #ifdef SUPPORT_UTF8
2289: utf8length = 1;
2290: if (common->utf8 && *cc >= 0xc0)
2291: utf8length += _pcre_utf8_table4[*cc & 0x3f];
2292:
2293: do
2294: {
2295: #endif
2296:
2297: context->length--;
2298: #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
2299:
2300: /* Unaligned read is supported. */
2301: if (othercasebit != 0 && othercasebyte == cc)
2302: {
2303: context->c.asbytes[context->byteptr] = *cc | othercasebit;
2304: context->oc.asbytes[context->byteptr] = othercasebit;
2305: }
2306: else
2307: {
2308: context->c.asbytes[context->byteptr] = *cc;
2309: context->oc.asbytes[context->byteptr] = 0;
2310: }
2311: context->byteptr++;
2312:
2313: if (context->byteptr >= 4 || context->length == 0 || (context->byteptr == 2 && context->length == 1))
2314: {
2315: if (context->length >= 4)
2316: OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
2317: else if (context->length >= 2)
2318: OP1(SLJIT_MOV_SH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
2319: else if (context->length >= 1)
2320: OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
2321: context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
2322:
2323: switch(context->byteptr)
2324: {
2325: case 4:
2326: if (context->oc.asint != 0)
2327: OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);
2328: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
2329: break;
2330:
2331: case 2:
2332: if (context->oc.asshort != 0)
2333: OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asshort);
2334: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asshort | context->oc.asshort));
2335: break;
2336:
2337: case 1:
2338: if (context->oc.asbyte != 0)
2339: OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);
2340: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
2341: break;
2342:
2343: default:
2344: SLJIT_ASSERT_STOP();
2345: break;
2346: }
2347: context->byteptr = 0;
2348: }
2349:
2350: #else
2351:
2352: /* Unaligned read is unsupported. */
2353: if (context->length > 0)
2354: OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
2355: context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
2356:
2357: if (othercasebit != 0 && othercasebyte == cc)
2358: {
2359: OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);
2360: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
2361: }
2362: else
2363: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
2364:
2365: #endif
2366:
2367: cc++;
2368: #ifdef SUPPORT_UTF8
2369: utf8length--;
2370: }
2371: while (utf8length > 0);
2372: #endif
2373:
2374: return cc;
2375: }
2376:
2377: #ifdef SUPPORT_UTF8
2378:
2379: #define SET_TYPE_OFFSET(value) \
2380: if ((value) != typeoffset) \
2381: { \
2382: if ((value) > typeoffset) \
2383: OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \
2384: else \
2385: OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \
2386: } \
2387: typeoffset = (value);
2388:
2389: #define SET_CHAR_OFFSET(value) \
2390: if ((value) != charoffset) \
2391: { \
2392: if ((value) > charoffset) \
2393: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (value) - charoffset); \
2394: else \
2395: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, charoffset - (value)); \
2396: } \
2397: charoffset = (value);
2398:
2399: static void compile_xclass_hotpath(compiler_common *common, uschar *cc, jump_list **fallbacks)
2400: {
2401: DEFINE_COMPILER;
2402: jump_list *found = NULL;
2403: jump_list **list = (*cc & XCL_NOT) == 0 ? &found : fallbacks;
2404: unsigned int c;
2405: int compares;
2406: struct sljit_jump *jump = NULL;
2407: uschar *ccbegin;
2408: #ifdef SUPPORT_UCP
2409: BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
2410: BOOL charsaved = FALSE;
2411: int typereg = TMP1, scriptreg = TMP1;
2412: unsigned int typeoffset;
2413: #endif
2414: int invertcmp, numberofcmps;
2415: unsigned int charoffset;
2416:
2417: /* Although SUPPORT_UTF8 must be defined, we are not necessary in utf8 mode. */
2418: check_input_end(common, fallbacks);
2419: read_char(common);
2420:
2421: if ((*cc++ & XCL_MAP) != 0)
2422: {
2423: OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
2424: if (common->utf8)
2425: jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
2426:
2427: OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
2428: OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
2429: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
2430: OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
2431: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
2432: add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));
2433:
2434: if (common->utf8)
2435: JUMPHERE(jump);
2436: OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
2437: #ifdef SUPPORT_UCP
2438: charsaved = TRUE;
2439: #endif
2440: cc += 32;
2441: }
2442:
2443: /* Scanning the necessary info. */
2444: ccbegin = cc;
2445: compares = 0;
2446: while (*cc != XCL_END)
2447: {
2448: compares++;
2449: if (*cc == XCL_SINGLE)
2450: {
2451: cc += 2;
2452: #ifdef SUPPORT_UTF8
2453: if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
2454: #endif
2455: #ifdef SUPPORT_UCP
2456: needschar = TRUE;
2457: #endif
2458: }
2459: else if (*cc == XCL_RANGE)
2460: {
2461: cc += 2;
2462: #ifdef SUPPORT_UTF8
2463: if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
2464: #endif
2465: cc++;
2466: #ifdef SUPPORT_UTF8
2467: if (common->utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
2468: #endif
2469: #ifdef SUPPORT_UCP
2470: needschar = TRUE;
2471: #endif
2472: }
2473: #ifdef SUPPORT_UCP
2474: else
2475: {
2476: SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
2477: cc++;
2478: switch(*cc)
2479: {
2480: case PT_ANY:
2481: break;
2482:
2483: case PT_LAMP:
2484: case PT_GC:
2485: case PT_PC:
2486: case PT_ALNUM:
2487: needstype = TRUE;
2488: break;
2489:
2490: case PT_SC:
2491: needsscript = TRUE;
2492: break;
2493:
2494: case PT_SPACE:
2495: case PT_PXSPACE:
2496: case PT_WORD:
2497: needstype = TRUE;
2498: needschar = TRUE;
2499: break;
2500:
2501: default:
2502: SLJIT_ASSERT_STOP();
2503: break;
2504: }
2505: cc += 2;
2506: }
2507: #endif
2508: }
2509:
2510: #ifdef SUPPORT_UCP
2511: /* Simple register allocation. TMP1 is preferred if possible. */
2512: if (needstype || needsscript)
2513: {
2514: if (needschar && !charsaved)
2515: OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
2516: add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
2517: if (needschar)
2518: {
2519: if (needstype)
2520: {
2521: OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
2522: typereg = RETURN_ADDR;
2523: }
2524:
2525: if (needsscript)
2526: scriptreg = TMP3;
2527: OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
2528: }
2529: else if (needstype && needsscript)
2530: scriptreg = TMP3;
2531: /* In all other cases only one of them was specified, and that can goes to TMP1. */
2532:
2533: if (needsscript)
2534: {
2535: if (scriptreg == TMP1)
2536: {
2537: OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_records + SLJIT_OFFSETOF(ucd_record, script));
2538: OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM2(scriptreg, TMP2), 3);
2539: }
2540: else
2541: {
2542: OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
2543: OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_w)_pcre_ucd_records + SLJIT_OFFSETOF(ucd_record, script));
2544: OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM1(TMP2), 0);
2545: }
2546: }
2547: }
2548: #endif
2549:
2550: /* Generating code. */
2551: cc = ccbegin;
2552: charoffset = 0;
2553: numberofcmps = 0;
2554: #ifdef SUPPORT_UCP
2555: typeoffset = 0;
2556: #endif
2557:
2558: while (*cc != XCL_END)
2559: {
2560: compares--;
2561: invertcmp = (compares == 0 && list != fallbacks);
2562: jump = NULL;
2563:
2564: if (*cc == XCL_SINGLE)
2565: {
2566: cc ++;
2567: #ifdef SUPPORT_UTF8
2568: if (common->utf8)
2569: {
2570: GETCHARINC(c, cc);
2571: }
2572: else
2573: #endif
2574: c = *cc++;
2575:
2576: if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
2577: {
2578: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
2579: COND_VALUE(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2580: numberofcmps++;
2581: }
2582: else if (numberofcmps > 0)
2583: {
2584: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
2585: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
2586: jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
2587: numberofcmps = 0;
2588: }
2589: else
2590: {
2591: jump = CMP(SLJIT_C_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);
2592: numberofcmps = 0;
2593: }
2594: }
2595: else if (*cc == XCL_RANGE)
2596: {
2597: cc ++;
2598: #ifdef SUPPORT_UTF8
2599: if (common->utf8)
2600: {
2601: GETCHARINC(c, cc);
2602: }
2603: else
2604: #endif
2605: c = *cc++;
2606: SET_CHAR_OFFSET(c);
2607: #ifdef SUPPORT_UTF8
2608: if (common->utf8)
2609: {
2610: GETCHARINC(c, cc);
2611: }
2612: else
2613: #endif
2614: c = *cc++;
2615: if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
2616: {
2617: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
2618: COND_VALUE(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
2619: numberofcmps++;
2620: }
2621: else if (numberofcmps > 0)
2622: {
2623: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);
2624: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);
2625: jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
2626: numberofcmps = 0;
2627: }
2628: else
2629: {
2630: jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);
2631: numberofcmps = 0;
2632: }
2633: }
2634: #ifdef SUPPORT_UCP
2635: else
2636: {
2637: if (*cc == XCL_NOTPROP)
2638: invertcmp ^= 0x1;
2639: cc++;
2640: switch(*cc)
2641: {
2642: case PT_ANY:
2643: if (list != fallbacks)
2644: {
2645: if ((cc[-1] == XCL_NOTPROP && compares > 0) || (cc[-1] == XCL_PROP && compares == 0))
2646: continue;
2647: }
2648: else if (cc[-1] == XCL_NOTPROP)
2649: continue;
2650: jump = JUMP(SLJIT_JUMP);
2651: break;
2652:
2653: case PT_LAMP:
2654: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset);
2655: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
2656: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset);
2657: COND_VALUE(SLJIT_OR, TMP2, 0, SLJIT_C_EQUAL);
2658: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset);
2659: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
2660: jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
2661: break;
2662:
2663: case PT_GC:
2664: c = _pcre_ucp_typerange[(int)cc[1] * 2];
2665: SET_TYPE_OFFSET(c);
2666: jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, _pcre_ucp_typerange[(int)cc[1] * 2 + 1] - c);
2667: break;
2668:
2669: case PT_PC:
2670: jump = CMP(SLJIT_C_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);
2671: break;
2672:
2673: case PT_SC:
2674: jump = CMP(SLJIT_C_EQUAL ^ invertcmp, scriptreg, 0, SLJIT_IMM, (int)cc[1]);
2675: break;
2676:
2677: case PT_SPACE:
2678: case PT_PXSPACE:
2679: if (*cc == PT_SPACE)
2680: {
2681: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
2682: jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 11 - charoffset);
2683: }
2684: SET_CHAR_OFFSET(9);
2685: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 13 - 9);
2686: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_LESS_EQUAL);
2687: if (*cc == PT_SPACE)
2688: JUMPHERE(jump);
2689:
2690: SET_TYPE_OFFSET(ucp_Zl);
2691: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);
2692: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);
2693: jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
2694: break;
2695:
2696: case PT_WORD:
2697: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);
2698: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
2699: /* ... fall through */
2700:
2701: case PT_ALNUM:
2702: SET_TYPE_OFFSET(ucp_Ll);
2703: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
2704: COND_VALUE((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_C_LESS_EQUAL);
2705: SET_TYPE_OFFSET(ucp_Nd);
2706: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd);
2707: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_LESS_EQUAL);
2708: jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);
2709: break;
2710: }
2711: cc += 2;
2712: }
2713: #endif
2714:
2715: if (jump != NULL)
2716: add_jump(compiler, compares > 0 ? list : fallbacks, jump);
2717: }
2718:
2719: if (found != NULL)
2720: set_jumps(found, LABEL());
2721: }
2722:
2723: #undef SET_TYPE_OFFSET
2724: #undef SET_CHAR_OFFSET
2725:
2726: #endif
2727:
2728: static uschar *compile_char1_hotpath(compiler_common *common, uschar type, uschar *cc, jump_list **fallbacks)
2729: {
2730: DEFINE_COMPILER;
2731: int length;
2732: unsigned int c, oc, bit;
2733: compare_context context;
2734: struct sljit_jump *jump[4];
2735: #ifdef SUPPORT_UTF8
2736: struct sljit_label *label;
2737: #ifdef SUPPORT_UCP
2738: uschar propdata[5];
2739: #endif
2740: #endif
2741:
2742: switch(type)
2743: {
2744: case OP_SOD:
2745: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
2746: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
2747: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
2748: return cc;
2749:
2750: case OP_SOM:
2751: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
2752: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
2753: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
2754: return cc;
2755:
2756: case OP_NOT_WORD_BOUNDARY:
2757: case OP_WORD_BOUNDARY:
2758: add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));
2759: add_jump(compiler, fallbacks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
2760: return cc;
2761:
2762: case OP_NOT_DIGIT:
2763: case OP_DIGIT:
2764: check_input_end(common, fallbacks);
2765: read_char8_type(common);
2766: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
2767: add_jump(compiler, fallbacks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
2768: return cc;
2769:
2770: case OP_NOT_WHITESPACE:
2771: case OP_WHITESPACE:
2772: check_input_end(common, fallbacks);
2773: read_char8_type(common);
2774: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
2775: add_jump(compiler, fallbacks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
2776: return cc;
2777:
2778: case OP_NOT_WORDCHAR:
2779: case OP_WORDCHAR:
2780: check_input_end(common, fallbacks);
2781: read_char8_type(common);
2782: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
2783: add_jump(compiler, fallbacks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));
2784: return cc;
2785:
2786: case OP_ANY:
2787: check_input_end(common, fallbacks);
2788: read_char(common);
2789: if (common->nltype == NLTYPE_FIXED && common->newline > 255)
2790: {
2791: jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
2792: jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
2793: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2794: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
2795: JUMPHERE(jump[1]);
2796: JUMPHERE(jump[0]);
2797: }
2798: else
2799: check_newlinechar(common, common->nltype, fallbacks, TRUE);
2800: return cc;
2801:
2802: case OP_ALLANY:
2803: check_input_end(common, fallbacks);
2804: #ifdef SUPPORT_UTF8
2805: if (common->utf8)
2806: {
2807: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2808: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2809: jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
2810: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes - 0xc0);
2811: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
2812: JUMPHERE(jump[0]);
2813: return cc;
2814: }
2815: #endif
2816: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2817: return cc;
2818:
2819: case OP_ANYBYTE:
2820: check_input_end(common, fallbacks);
2821: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2822: return cc;
2823:
2824: #ifdef SUPPORT_UTF8
2825: #ifdef SUPPORT_UCP
2826: case OP_NOTPROP:
2827: case OP_PROP:
2828: propdata[0] = 0;
2829: propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;
2830: propdata[2] = cc[0];
2831: propdata[3] = cc[1];
2832: propdata[4] = XCL_END;
2833: compile_xclass_hotpath(common, propdata, fallbacks);
2834: return cc + 2;
2835: #endif
2836: #endif
2837:
2838: case OP_ANYNL:
2839: check_input_end(common, fallbacks);
2840: read_char(common);
2841: jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
2842: jump[1] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
2843: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2844: jump[2] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
2845: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
2846: jump[3] = JUMP(SLJIT_JUMP);
2847: JUMPHERE(jump[0]);
2848: check_newlinechar(common, common->bsr_nltype, fallbacks, FALSE);
2849: JUMPHERE(jump[1]);
2850: JUMPHERE(jump[2]);
2851: JUMPHERE(jump[3]);
2852: return cc;
2853:
2854: case OP_NOT_HSPACE:
2855: case OP_HSPACE:
2856: check_input_end(common, fallbacks);
2857: read_char(common);
2858: add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));
2859: add_jump(compiler, fallbacks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
2860: return cc;
2861:
2862: case OP_NOT_VSPACE:
2863: case OP_VSPACE:
2864: check_input_end(common, fallbacks);
2865: read_char(common);
2866: add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));
2867: add_jump(compiler, fallbacks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));
2868: return cc;
2869:
2870: #ifdef SUPPORT_UCP
2871: case OP_EXTUNI:
2872: check_input_end(common, fallbacks);
2873: read_char(common);
2874: add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
2875: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);
2876: add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc));
2877:
2878: label = LABEL();
2879: jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
2880: OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
2881: read_char(common);
2882: add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
2883: OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Mc);
2884: CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, ucp_Mn - ucp_Mc, label);
2885:
2886: OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
2887: JUMPHERE(jump[0]);
2888: return cc;
2889: #endif
2890:
2891: case OP_EODN:
2892: jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
2893: if (common->nltype == NLTYPE_FIXED && common->newline > 255)
2894: {
2895: OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
2896: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2897: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
2898: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
2899: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
2900: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
2901: }
2902: else if (common->nltype == NLTYPE_FIXED)
2903: {
2904: OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 1);
2905: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2906: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));
2907: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
2908: }
2909: else
2910: {
2911: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
2912: jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
2913: OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
2914: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
2915: jump[2] = JUMP(SLJIT_C_GREATER);
2916: add_jump(compiler, fallbacks, JUMP(SLJIT_C_LESS));
2917: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 1);
2918: jump[3] = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
2919: add_jump(compiler, fallbacks, JUMP(SLJIT_JUMP));
2920:
2921: JUMPHERE(jump[1]);
2922: if (common->nltype == NLTYPE_ANYCRLF)
2923: {
2924: OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 1);
2925: add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));
2926: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
2927: }
2928: else
2929: {
2930: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, STR_PTR, 0);
2931: read_char(common);
2932: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
2933: add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
2934: add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
2935: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
2936: }
2937: JUMPHERE(jump[2]);
2938: JUMPHERE(jump[3]);
2939: }
2940: JUMPHERE(jump[0]);
2941: return cc;
2942:
2943: case OP_EOD:
2944: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
2945: return cc;
2946:
2947: case OP_CIRC:
2948: OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
2949: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
2950: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0));
2951: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
2952: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
2953: return cc;
2954:
2955: case OP_CIRCM:
2956: OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
2957: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
2958: jump[1] = CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0);
2959: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
2960: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
2961: jump[0] = JUMP(SLJIT_JUMP);
2962: JUMPHERE(jump[1]);
2963:
2964: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, end));
2965: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP2, 0, STR_PTR, 0));
2966:
2967: if (common->nltype == NLTYPE_FIXED && common->newline > 255)
2968: {
2969: OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
2970: add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));
2971: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -2);
2972: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), -1);
2973: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
2974: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
2975: }
2976: else
2977: {
2978: skip_char_back(common);
2979: read_char(common);
2980: check_newlinechar(common, common->nltype, fallbacks, FALSE);
2981: }
2982: JUMPHERE(jump[0]);
2983: return cc;
2984:
2985: case OP_DOLL:
2986: OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
2987: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
2988: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
2989:
2990: if (!common->endonly)
2991: compile_char1_hotpath(common, OP_EODN, cc, fallbacks);
2992: else
2993: add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));
2994: return cc;
2995:
2996: case OP_DOLLM:
2997: jump[1] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);
2998: OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
2999: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
3000: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
3001: jump[0] = JUMP(SLJIT_JUMP);
3002: JUMPHERE(jump[1]);
3003:
3004: if (common->nltype == NLTYPE_FIXED && common->newline > 255)
3005: {
3006: OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 2);
3007: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));
3008: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
3009: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(STR_PTR), 1);
3010: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
3011: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
3012: }
3013: else
3014: {
3015: peek_char(common);
3016: check_newlinechar(common, common->nltype, fallbacks, FALSE);
3017: }
3018: JUMPHERE(jump[0]);
3019: return cc;
3020:
3021: case OP_CHAR:
3022: case OP_CHARI:
3023: length = 1;
3024: #ifdef SUPPORT_UTF8
3025: if (common->utf8 && *cc >= 0xc0) length += _pcre_utf8_table4[*cc & 0x3f];
3026: #endif
3027: if (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0)
3028: {
3029: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, length);
3030: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
3031:
3032: context.length = length;
3033: context.sourcereg = -1;
3034: #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
3035: context.byteptr = 0;
3036: #endif
3037: return byte_sequence_compare(common, type == OP_CHARI, cc, &context, fallbacks);
3038: }
3039: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
3040: read_char(common);
3041: #ifdef SUPPORT_UTF8
3042: if (common->utf8)
3043: {
3044: GETCHAR(c, cc);
3045: }
3046: else
3047: #endif
3048: c = *cc;
3049: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);
3050: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
3051: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char_othercase(common, c));
3052: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
3053: add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
3054: return cc + length;
3055:
3056: case OP_NOT:
3057: case OP_NOTI:
3058: length = 1;
3059: #ifdef SUPPORT_UTF8
3060: if (common->utf8)
3061: {
3062: if (*cc >= 0xc0) length += _pcre_utf8_table4[*cc & 0x3f];
3063:
3064: check_input_end(common, fallbacks);
3065: GETCHAR(c, cc);
3066:
3067: if (c <= 127)
3068: {
3069: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
3070: if (type == OP_NOT || !char_has_othercase(common, cc))
3071: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
3072: else
3073: {
3074: /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */
3075: OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);
3076: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
3077: }
3078: /* Skip the variable-length character. */
3079: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
3080: jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
3081: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)_pcre_utf8_char_sizes - 0xc0);
3082: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
3083: JUMPHERE(jump[0]);
3084: return cc + length;
3085: }
3086: else
3087: read_char(common);
3088: }
3089: else
3090: #endif
3091: {
3092: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 1);
3093: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
3094: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -1);
3095: c = *cc;
3096: }
3097:
3098: if (type == OP_NOT || !char_has_othercase(common, cc))
3099: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
3100: else
3101: {
3102: oc = char_othercase(common, c);
3103: bit = c ^ oc;
3104: if (ispowerof2(bit))
3105: {
3106: OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
3107: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
3108: }
3109: else
3110: {
3111: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));
3112: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));
3113: }
3114: }
3115: return cc + length;
3116:
3117: case OP_CLASS:
3118: case OP_NCLASS:
3119: check_input_end(common, fallbacks);
3120: read_char(common);
3121: #ifdef SUPPORT_UTF8
3122: jump[0] = NULL;
3123: if (common->utf8)
3124: {
3125: jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);
3126: if (type == OP_CLASS)
3127: {
3128: add_jump(compiler, fallbacks, jump[0]);
3129: jump[0] = NULL;
3130: }
3131: }
3132: #endif
3133: OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
3134: OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
3135: OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_w)cc);
3136: OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
3137: OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
3138: add_jump(compiler, fallbacks, JUMP(SLJIT_C_ZERO));
3139: #ifdef SUPPORT_UTF8
3140: if (jump[0] != NULL)
3141: JUMPHERE(jump[0]);
3142: #endif
3143: return cc + 32;
3144:
3145: #ifdef SUPPORT_UTF8
3146: case OP_XCLASS:
3147: compile_xclass_hotpath(common, cc + LINK_SIZE, fallbacks);
3148: return cc + GET(cc, 0) - 1;
3149: #endif
3150:
3151: case OP_REVERSE:
3152: length = GET(cc, 0);
3153: SLJIT_ASSERT(length > 0);
3154: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
3155: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
3156: #ifdef SUPPORT_UTF8
3157: if (common->utf8)
3158: {
3159: OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);
3160: label = LABEL();
3161: add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0));
3162: skip_char_back(common);
3163: OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
3164: JUMPTO(SLJIT_C_NOT_ZERO, label);
3165: return cc + LINK_SIZE;
3166: }
3167: #endif
3168: OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, length);
3169: add_jump(compiler, fallbacks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));
3170: return cc + LINK_SIZE;
3171: }
3172: SLJIT_ASSERT_STOP();
3173: return cc;
3174: }
3175:
3176: static SLJIT_INLINE uschar *compile_charn_hotpath(compiler_common *common, uschar *cc, uschar *ccend, jump_list **fallbacks)
3177: {
3178: /* This function consumes at least one input character. */
3179: /* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */
3180: DEFINE_COMPILER;
3181: uschar *ccbegin = cc;
3182: compare_context context;
3183: int size;
3184:
3185: context.length = 0;
3186: do
3187: {
3188: if (cc >= ccend)
3189: break;
3190:
3191: if (*cc == OP_CHAR)
3192: {
3193: size = 1;
3194: #ifdef SUPPORT_UTF8
3195: if (common->utf8 && cc[1] >= 0xc0)
3196: size += _pcre_utf8_table4[cc[1] & 0x3f];
3197: #endif
3198: }
3199: else if (*cc == OP_CHARI)
3200: {
3201: size = 1;
3202: #ifdef SUPPORT_UTF8
3203: if (common->utf8)
3204: {
3205: if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
3206: size = 0;
3207: else if (cc[1] >= 0xc0)
3208: size += _pcre_utf8_table4[cc[1] & 0x3f];
3209: }
3210: else
3211: #endif
3212: if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
3213: size = 0;
3214: }
3215: else
3216: size = 0;
3217:
3218: cc += 1 + size;
3219: context.length += size;
3220: }
3221: while (size > 0 && context.length <= 128);
3222:
3223: cc = ccbegin;
3224: if (context.length > 0)
3225: {
3226: /* We have a fixed-length byte sequence. */
3227: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);
3228: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
3229:
3230: context.sourcereg = -1;
3231: #if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
3232: context.byteptr = 0;
3233: #endif
3234: do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, fallbacks); while (context.length > 0);
3235: return cc;
3236: }
3237:
3238: /* A non-fixed length character will be checked if length == 0. */
3239: return compile_char1_hotpath(common, *cc, cc + 1, fallbacks);
3240: }
3241:
3242: static struct sljit_jump *compile_ref_checks(compiler_common *common, uschar *cc, jump_list **fallbacks)
3243: {
3244: DEFINE_COMPILER;
3245: int offset = GET2(cc, 1) << 1;
3246:
3247: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
3248: if (!common->jscript_compat)
3249: {
3250: if (fallbacks == NULL)
3251: {
3252: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
3253: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_EQUAL);
3254: OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
3255: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_EQUAL);
3256: return JUMP(SLJIT_C_NOT_ZERO);
3257: }
3258: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
3259: }
3260: return CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
3261: }
3262:
3263: /* Forward definitions. */
3264: static void compile_hotpath(compiler_common *, uschar *, uschar *, fallback_common *);
3265: static void compile_fallbackpath(compiler_common *, struct fallback_common *);
3266:
3267: #define PUSH_FALLBACK(size, ccstart, error) \
3268: do \
3269: { \
3270: fallback = sljit_alloc_memory(compiler, (size)); \
3271: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
3272: return error; \
3273: memset(fallback, 0, size); \
3274: fallback->prev = parent->top; \
3275: fallback->cc = (ccstart); \
3276: parent->top = fallback; \
3277: } \
3278: while (0)
3279:
3280: #define PUSH_FALLBACK_NOVALUE(size, ccstart) \
3281: do \
3282: { \
3283: fallback = sljit_alloc_memory(compiler, (size)); \
3284: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
3285: return; \
3286: memset(fallback, 0, size); \
3287: fallback->prev = parent->top; \
3288: fallback->cc = (ccstart); \
3289: parent->top = fallback; \
3290: } \
3291: while (0)
3292:
3293: #define FALLBACK_AS(type) ((type*)fallback)
3294:
3295: static uschar *compile_ref_hotpath(compiler_common *common, uschar *cc, jump_list **fallbacks, BOOL withchecks, BOOL emptyfail)
3296: {
3297: DEFINE_COMPILER;
3298: int offset = GET2(cc, 1) << 1;
3299: struct sljit_jump *jump = NULL;
3300:
3301: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
3302: if (withchecks && !common->jscript_compat)
3303: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
3304:
3305: #ifdef SUPPORT_UTF8
3306: #ifdef SUPPORT_UCP
3307: if (common->utf8 && *cc == OP_REFI)
3308: {
3309: SLJIT_ASSERT(TMP1 == SLJIT_TEMPORARY_REG1 && STACK_TOP == SLJIT_TEMPORARY_REG2 && TMP2 == SLJIT_TEMPORARY_REG3);
3310: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
3311: if (withchecks)
3312: jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);
3313:
3314: /* Needed to save important temporary registers. */
3315: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);
3316: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, ARGUMENTS, 0);
3317: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_TEMPORARY_REG2), SLJIT_OFFSETOF(jit_arguments, ptr), STR_PTR, 0);
3318: sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf8caselesscmp));
3319: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
3320: add_jump(compiler, fallbacks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));
3321: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);
3322: }
3323: else
3324: #endif
3325: #endif
3326: {
3327: OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);
3328: if (withchecks)
3329: jump = JUMP(SLJIT_C_ZERO);
3330: OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
3331:
3332: add_jump(compiler, fallbacks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));
3333: add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
3334: add_jump(compiler, fallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
3335: }
3336:
3337: if (jump != NULL)
3338: {
3339: if (emptyfail)
3340: add_jump(compiler, fallbacks, jump);
3341: else
3342: JUMPHERE(jump);
3343: }
3344: return cc + 3;
3345: }
3346:
3347: static SLJIT_INLINE uschar *compile_ref_iterator_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
3348: {
3349: DEFINE_COMPILER;
3350: fallback_common *fallback;
3351: uschar type;
3352: struct sljit_label *label;
3353: struct sljit_jump *zerolength;
3354: struct sljit_jump *jump = NULL;
3355: uschar *ccbegin = cc;
3356: int min = 0, max = 0;
3357: BOOL minimize;
3358:
3359: PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);
3360:
3361: type = cc[3];
3362: minimize = (type & 0x1) != 0;
3363: switch(type)
3364: {
3365: case OP_CRSTAR:
3366: case OP_CRMINSTAR:
3367: min = 0;
3368: max = 0;
3369: cc += 4;
3370: break;
3371: case OP_CRPLUS:
3372: case OP_CRMINPLUS:
3373: min = 1;
3374: max = 0;
3375: cc += 4;
3376: break;
3377: case OP_CRQUERY:
3378: case OP_CRMINQUERY:
3379: min = 0;
3380: max = 1;
3381: cc += 4;
3382: break;
3383: case OP_CRRANGE:
3384: case OP_CRMINRANGE:
3385: min = GET2(cc, 3 + 1);
3386: max = GET2(cc, 3 + 3);
3387: cc += 8;
3388: break;
3389: default:
3390: SLJIT_ASSERT_STOP();
3391: break;
3392: }
3393:
3394: if (!minimize)
3395: {
3396: if (min == 0)
3397: {
3398: allocate_stack(common, 2);
3399: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
3400: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
3401: /* Temporary release of STR_PTR. */
3402: OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
3403: zerolength = compile_ref_checks(common, ccbegin, NULL);
3404: /* Restore if not zero length. */
3405: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
3406: }
3407: else
3408: {
3409: allocate_stack(common, 1);
3410: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3411: zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);
3412: }
3413:
3414: if (min > 1 || max > 1)
3415: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
3416:
3417: label = LABEL();
3418: compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, FALSE, FALSE);
3419:
3420: if (min > 1 || max > 1)
3421: {
3422: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
3423: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
3424: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
3425: if (min > 1)
3426: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, label);
3427: if (max > 1)
3428: {
3429: jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);
3430: allocate_stack(common, 1);
3431: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
3432: JUMPTO(SLJIT_JUMP, label);
3433: JUMPHERE(jump);
3434: }
3435: }
3436:
3437: if (max == 0)
3438: {
3439: /* Includes min > 1 case as well. */
3440: allocate_stack(common, 1);
3441: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
3442: JUMPTO(SLJIT_JUMP, label);
3443: }
3444:
3445: JUMPHERE(zerolength);
3446: FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
3447:
3448: decrease_call_count(common);
3449: return cc;
3450: }
3451:
3452: allocate_stack(common, 2);
3453: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3454: if (type != OP_CRMINSTAR)
3455: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
3456:
3457: if (min == 0)
3458: {
3459: zerolength = compile_ref_checks(common, ccbegin, NULL);
3460: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
3461: jump = JUMP(SLJIT_JUMP);
3462: }
3463: else
3464: zerolength = compile_ref_checks(common, ccbegin, &fallback->topfallbacks);
3465:
3466: FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
3467: if (max > 0)
3468: add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
3469:
3470: compile_ref_hotpath(common, ccbegin, &fallback->topfallbacks, TRUE, TRUE);
3471: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
3472:
3473: if (min > 1)
3474: {
3475: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
3476: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
3477: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
3478: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, FALLBACK_AS(iterator_fallback)->hotpath);
3479: }
3480: else if (max > 0)
3481: OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
3482:
3483: if (jump != NULL)
3484: JUMPHERE(jump);
3485: JUMPHERE(zerolength);
3486:
3487: decrease_call_count(common);
3488: return cc;
3489: }
3490:
3491: static SLJIT_INLINE uschar *compile_recurse_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
3492: {
3493: DEFINE_COMPILER;
3494: fallback_common *fallback;
3495: recurse_entry *entry = common->entries;
3496: recurse_entry *prev = NULL;
3497: int start = GET(cc, 1);
3498:
3499: PUSH_FALLBACK(sizeof(recurse_fallback), cc, NULL);
3500: while (entry != NULL)
3501: {
3502: if (entry->start == start)
3503: break;
3504: prev = entry;
3505: entry = entry->next;
3506: }
3507:
3508: if (entry == NULL)
3509: {
3510: entry = sljit_alloc_memory(compiler, sizeof(recurse_entry));
3511: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
3512: return NULL;
3513: entry->next = NULL;
3514: entry->entry = NULL;
3515: entry->calls = NULL;
3516: entry->start = start;
3517:
3518: if (prev != NULL)
3519: prev->next = entry;
3520: else
3521: common->entries = entry;
3522: }
3523:
3524: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
3525: allocate_stack(common, 1);
3526: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
3527:
3528: if (entry->entry == NULL)
3529: add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));
3530: else
3531: JUMPTO(SLJIT_FAST_CALL, entry->entry);
3532: /* Leave if the match is failed. */
3533: add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0));
3534: return cc + 1 + LINK_SIZE;
3535: }
3536:
3537: static uschar *compile_assert_hotpath(compiler_common *common, uschar *cc, assert_fallback *fallback, BOOL conditional)
3538: {
3539: DEFINE_COMPILER;
3540: int framesize;
3541: int localptr;
3542: fallback_common altfallback;
3543: uschar *ccbegin;
3544: uschar opcode;
3545: uschar bra = OP_BRA;
3546: jump_list *tmp = NULL;
3547: jump_list **target = (conditional) ? &fallback->condfailed : &fallback->common.topfallbacks;
3548: jump_list **found;
3549: /* Saving previous accept variables. */
3550: struct sljit_label *save_acceptlabel = common->acceptlabel;
3551: struct sljit_jump *jump;
3552: struct sljit_jump *brajump = NULL;
3553: jump_list *save_accept = common->accept;
3554:
3555: if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
3556: {
3557: SLJIT_ASSERT(!conditional);
3558: bra = *cc;
3559: cc++;
3560: }
3561: localptr = PRIV(cc);
3562: SLJIT_ASSERT(localptr != 0);
3563: framesize = get_framesize(common, cc, FALSE);
3564: fallback->framesize = framesize;
3565: fallback->localptr = localptr;
3566: opcode = *cc;
3567: SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);
3568: found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;
3569: ccbegin = cc;
3570: cc += GET(cc, 1);
3571:
3572: if (bra == OP_BRAMINZERO)
3573: {
3574: /* This is a braminzero fallback path. */
3575: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
3576: free_stack(common, 1);
3577: brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
3578: }
3579:
3580: if (framesize < 0)
3581: {
3582: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);
3583: allocate_stack(common, 1);
3584: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
3585: }
3586: else
3587: {
3588: allocate_stack(common, framesize + 2);
3589: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
3590: OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(framesize + 1));
3591: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
3592: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
3593: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
3594: init_frame(common, ccbegin, framesize + 1, 2, FALSE);
3595: }
3596:
3597: memset(&altfallback, 0, sizeof(fallback_common));
3598: while (1)
3599: {
3600: common->acceptlabel = NULL;
3601: common->accept = NULL;
3602: altfallback.top = NULL;
3603: altfallback.topfallbacks = NULL;
3604:
3605: if (*ccbegin == OP_ALT)
3606: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
3607:
3608: altfallback.cc = ccbegin;
3609: compile_hotpath(common, ccbegin + 1 + LINK_SIZE, cc, &altfallback);
3610: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
3611: {
3612: common->acceptlabel = save_acceptlabel;
3613: common->accept = save_accept;
3614: return NULL;
3615: }
3616: common->acceptlabel = LABEL();
3617: if (common->accept != NULL)
3618: set_jumps(common->accept, common->acceptlabel);
3619:
3620: /* Reset stack. */
3621: if (framesize < 0)
3622: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
3623: else {
3624: if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
3625: {
3626: /* We don't need to keep the STR_PTR, only the previous localptr. */
3627: OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
3628: }
3629: else
3630: {
3631: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
3632: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
3633: }
3634: }
3635:
3636: if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
3637: {
3638: /* We know that STR_PTR was stored on the top of the stack. */
3639: if (conditional)
3640: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
3641: else if (bra == OP_BRAZERO)
3642: {
3643: if (framesize < 0)
3644: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
3645: else
3646: {
3647: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
3648: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_w));
3649: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
3650: }
3651: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
3652: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3653: }
3654: else if (framesize >= 0)
3655: {
3656: /* For OP_BRA and OP_BRAMINZERO. */
3657: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
3658: }
3659: }
3660: add_jump(compiler, found, JUMP(SLJIT_JUMP));
3661:
3662: compile_fallbackpath(common, altfallback.top);
3663: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
3664: {
3665: common->acceptlabel = save_acceptlabel;
3666: common->accept = save_accept;
3667: return NULL;
3668: }
3669: set_jumps(altfallback.topfallbacks, LABEL());
3670:
3671: if (*cc != OP_ALT)
3672: break;
3673:
3674: ccbegin = cc;
3675: cc += GET(cc, 1);
3676: }
3677: /* None of them matched. */
3678:
3679: if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
3680: {
3681: /* Assert is failed. */
3682: if (conditional || bra == OP_BRAZERO)
3683: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
3684:
3685: if (framesize < 0)
3686: {
3687: /* The topmost item should be 0. */
3688: if (bra == OP_BRAZERO)
3689: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3690: else
3691: free_stack(common, 1);
3692: }
3693: else
3694: {
3695: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
3696: /* The topmost item should be 0. */
3697: if (bra == OP_BRAZERO)
3698: {
3699: free_stack(common, framesize + 1);
3700: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3701: }
3702: else
3703: free_stack(common, framesize + 2);
3704: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
3705: }
3706: jump = JUMP(SLJIT_JUMP);
3707: if (bra != OP_BRAZERO)
3708: add_jump(compiler, target, jump);
3709:
3710: /* Assert is successful. */
3711: set_jumps(tmp, LABEL());
3712: if (framesize < 0)
3713: {
3714: /* We know that STR_PTR was stored on the top of the stack. */
3715: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
3716: /* Keep the STR_PTR on the top of the stack. */
3717: if (bra == OP_BRAZERO)
3718: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
3719: else if (bra == OP_BRAMINZERO)
3720: {
3721: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
3722: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3723: }
3724: }
3725: else
3726: {
3727: if (bra == OP_BRA)
3728: {
3729: /* We don't need to keep the STR_PTR, only the previous localptr. */
3730: OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_w));
3731: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
3732: }
3733: else
3734: {
3735: /* We don't need to keep the STR_PTR, only the previous localptr. */
3736: OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_w));
3737: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
3738: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
3739: }
3740: }
3741:
3742: if (bra == OP_BRAZERO)
3743: {
3744: fallback->hotpath = LABEL();
3745: sljit_set_label(jump, fallback->hotpath);
3746: }
3747: else if (bra == OP_BRAMINZERO)
3748: {
3749: JUMPTO(SLJIT_JUMP, fallback->hotpath);
3750: JUMPHERE(brajump);
3751: if (framesize >= 0)
3752: {
3753: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
3754: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
3755: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_w));
3756: }
3757: set_jumps(fallback->common.topfallbacks, LABEL());
3758: }
3759: }
3760: else
3761: {
3762: /* AssertNot is successful. */
3763: if (framesize < 0)
3764: {
3765: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
3766: if (bra != OP_BRA)
3767: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3768: else
3769: free_stack(common, 1);
3770: }
3771: else
3772: {
3773: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
3774: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
3775: /* The topmost item should be 0. */
3776: if (bra != OP_BRA)
3777: {
3778: free_stack(common, framesize + 1);
3779: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
3780: }
3781: else
3782: free_stack(common, framesize + 2);
3783: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
3784: }
3785:
3786: if (bra == OP_BRAZERO)
3787: fallback->hotpath = LABEL();
3788: else if (bra == OP_BRAMINZERO)
3789: {
3790: JUMPTO(SLJIT_JUMP, fallback->hotpath);
3791: JUMPHERE(brajump);
3792: }
3793:
3794: if (bra != OP_BRA)
3795: {
3796: SLJIT_ASSERT(found == &fallback->common.topfallbacks);
3797: set_jumps(fallback->common.topfallbacks, LABEL());
3798: fallback->common.topfallbacks = NULL;
3799: }
3800: }
3801:
3802: common->acceptlabel = save_acceptlabel;
3803: common->accept = save_accept;
3804: return cc + 1 + LINK_SIZE;
3805: }
3806:
3807: static sljit_w SLJIT_CALL do_searchovector(sljit_w refno, sljit_w* locals, uschar *name_table)
3808: {
3809: int condition = FALSE;
3810: uschar *slotA = name_table;
3811: uschar *slotB;
3812: sljit_w name_count = locals[LOCALS0 / sizeof(sljit_w)];
3813: sljit_w name_entry_size = locals[LOCALS1 / sizeof(sljit_w)];
3814: sljit_w no_capture;
3815: int i;
3816:
3817: locals += OVECTOR_START / sizeof(sljit_w);
3818: no_capture = locals[1];
3819:
3820: for (i = 0; i < name_count; i++)
3821: {
3822: if (GET2(slotA, 0) == refno) break;
3823: slotA += name_entry_size;
3824: }
3825:
3826: if (i < name_count)
3827: {
3828: /* Found a name for the number - there can be only one; duplicate names
3829: for different numbers are allowed, but not vice versa. First scan down
3830: for duplicates. */
3831:
3832: slotB = slotA;
3833: while (slotB > name_table)
3834: {
3835: slotB -= name_entry_size;
3836: if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
3837: {
3838: condition = locals[GET2(slotB, 0) << 1] != no_capture;
3839: if (condition) break;
3840: }
3841: else break;
3842: }
3843:
3844: /* Scan up for duplicates */
3845: if (!condition)
3846: {
3847: slotB = slotA;
3848: for (i++; i < name_count; i++)
3849: {
3850: slotB += name_entry_size;
3851: if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
3852: {
3853: condition = locals[GET2(slotB, 0) << 1] != no_capture;
3854: if (condition) break;
3855: }
3856: else break;
3857: }
3858: }
3859: }
3860: return condition;
3861: }
3862:
3863: static sljit_w SLJIT_CALL do_searchgroups(sljit_w recno, sljit_w* locals, uschar *name_table)
3864: {
3865: int condition = FALSE;
3866: uschar *slotA = name_table;
3867: uschar *slotB;
3868: sljit_w name_count = locals[LOCALS0 / sizeof(sljit_w)];
3869: sljit_w name_entry_size = locals[LOCALS1 / sizeof(sljit_w)];
3870: sljit_w group_num = locals[POSSESSIVE0 / sizeof(sljit_w)];
3871: int i;
3872:
3873: for (i = 0; i < name_count; i++)
3874: {
3875: if (GET2(slotA, 0) == recno) break;
3876: slotA += name_entry_size;
3877: }
3878:
3879: if (i < name_count)
3880: {
3881: /* Found a name for the number - there can be only one; duplicate
3882: names for different numbers are allowed, but not vice versa. First
3883: scan down for duplicates. */
3884:
3885: slotB = slotA;
3886: while (slotB > name_table)
3887: {
3888: slotB -= name_entry_size;
3889: if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
3890: {
3891: condition = GET2(slotB, 0) == group_num;
3892: if (condition) break;
3893: }
3894: else break;
3895: }
3896:
3897: /* Scan up for duplicates */
3898: if (!condition)
3899: {
3900: slotB = slotA;
3901: for (i++; i < name_count; i++)
3902: {
3903: slotB += name_entry_size;
3904: if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
3905: {
3906: condition = GET2(slotB, 0) == group_num;
3907: if (condition) break;
3908: }
3909: else break;
3910: }
3911: }
3912: }
3913: return condition;
3914: }
3915:
3916: /*
3917: Handling bracketed expressions is probably the most complex part.
3918:
3919: Stack layout naming characters:
3920: S - Push the current STR_PTR
3921: 0 - Push a 0 (NULL)
3922: A - Push the current STR_PTR. Needed for restoring the STR_PTR
3923: before the next alternative. Not pushed if there are no alternatives.
3924: M - Any values pushed by the current alternative. Can be empty, or anything.
3925: C - Push the previous OVECTOR(i), OVECTOR(i+1) and OVECTOR_PRIV(i) to the stack.
3926: L - Push the previous local (pointed by localptr) to the stack
3927: () - opional values stored on the stack
3928: ()* - optonal, can be stored multiple times
3929:
3930: The following list shows the regular expression templates, their PCRE byte codes
3931: and stack layout supported by pcre-sljit.
3932:
3933: (?:) OP_BRA | OP_KET A M
3934: () OP_CBRA | OP_KET C M
3935: (?:)+ OP_BRA | OP_KETRMAX 0 A M S ( A M S )*
3936: OP_SBRA | OP_KETRMAX 0 L M S ( L M S )*
3937: (?:)+? OP_BRA | OP_KETRMIN 0 A M S ( A M S )*
3938: OP_SBRA | OP_KETRMIN 0 L M S ( L M S )*
3939: ()+ OP_CBRA | OP_KETRMAX 0 C M S ( C M S )*
3940: OP_SCBRA | OP_KETRMAX 0 C M S ( C M S )*
3941: ()+? OP_CBRA | OP_KETRMIN 0 C M S ( C M S )*
3942: OP_SCBRA | OP_KETRMIN 0 C M S ( C M S )*
3943: (?:)? OP_BRAZERO | OP_BRA | OP_KET S ( A M 0 )
3944: (?:)?? OP_BRAMINZERO | OP_BRA | OP_KET S ( A M 0 )
3945: ()? OP_BRAZERO | OP_CBRA | OP_KET S ( C M 0 )
3946: ()?? OP_BRAMINZERO | OP_CBRA | OP_KET S ( C M 0 )
3947: (?:)* OP_BRAZERO | OP_BRA | OP_KETRMAX S 0 ( A M S )*
3948: OP_BRAZERO | OP_SBRA | OP_KETRMAX S 0 ( L M S )*
3949: (?:)*? OP_BRAMINZERO | OP_BRA | OP_KETRMIN S 0 ( A M S )*
3950: OP_BRAMINZERO | OP_SBRA | OP_KETRMIN S 0 ( L M S )*
3951: ()* OP_BRAZERO | OP_CBRA | OP_KETRMAX S 0 ( C M S )*
3952: OP_BRAZERO | OP_SCBRA | OP_KETRMAX S 0 ( C M S )*
3953: ()*? OP_BRAMINZERO | OP_CBRA | OP_KETRMIN S 0 ( C M S )*
3954: OP_BRAMINZERO | OP_SCBRA | OP_KETRMIN S 0 ( C M S )*
3955:
3956:
3957: Stack layout naming characters:
3958: A - Push the alternative index (starting from 0) on the stack.
3959: Not pushed if there is no alternatives.
3960: M - Any values pushed by the current alternative. Can be empty, or anything.
3961:
3962: The next list shows the possible content of a bracket:
3963: (|) OP_*BRA | OP_ALT ... M A
3964: (?()|) OP_*COND | OP_ALT M A
3965: (?>|) OP_ONCE | OP_ALT ... [stack trace] M A
3966: (?>|) OP_ONCE_NC | OP_ALT ... [stack trace] M A
3967: Or nothing, if trace is unnecessary
3968: */
3969:
3970: static uschar *compile_bracket_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
3971: {
3972: DEFINE_COMPILER;
3973: fallback_common *fallback;
3974: uschar opcode;
3975: int localptr = 0;
3976: int offset = 0;
3977: int stacksize;
3978: uschar *ccbegin;
3979: uschar *hotpath;
3980: uschar bra = OP_BRA;
3981: uschar ket;
3982: assert_fallback *assert;
3983: BOOL has_alternatives;
3984: struct sljit_jump *jump;
3985: struct sljit_jump *skip;
3986: struct sljit_label *rmaxlabel = NULL;
3987: struct sljit_jump *braminzerojump = NULL;
3988:
3989: PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);
3990:
3991: if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
3992: {
3993: bra = *cc;
3994: cc++;
3995: opcode = *cc;
3996: }
3997:
3998: opcode = *cc;
3999: ccbegin = cc;
4000: hotpath = ccbegin + 1 + LINK_SIZE;
4001:
4002: if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
4003: {
4004: /* Drop this bracket_fallback. */
4005: parent->top = fallback->prev;
4006: return bracketend(cc);
4007: }
4008:
4009: ket = *(bracketend(cc) - 1 - LINK_SIZE);
4010: SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);
4011: SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));
4012: cc += GET(cc, 1);
4013:
4014: has_alternatives = *cc == OP_ALT;
4015: if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
4016: {
4017: has_alternatives = (*hotpath == OP_RREF) ? FALSE : TRUE;
4018: if (*hotpath == OP_NRREF)
4019: {
4020: stacksize = GET2(hotpath, 1);
4021: if (common->currententry == NULL || stacksize == RREF_ANY)
4022: has_alternatives = FALSE;
4023: else if (common->currententry->start == 0)
4024: has_alternatives = stacksize != 0;
4025: else
4026: has_alternatives = stacksize != GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
4027: }
4028: }
4029:
4030: if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
4031: opcode = OP_SCOND;
4032: if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
4033: opcode = OP_ONCE;
4034:
4035: if (opcode == OP_CBRA || opcode == OP_SCBRA)
4036: {
4037: /* Capturing brackets has a pre-allocated space. */
4038: offset = GET2(ccbegin, 1 + LINK_SIZE);
4039: localptr = OVECTOR_PRIV(offset);
4040: offset <<= 1;
4041: FALLBACK_AS(bracket_fallback)->localptr = localptr;
4042: hotpath += 2;
4043: }
4044: else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)
4045: {
4046: /* Other brackets simply allocate the next entry. */
4047: localptr = PRIV(ccbegin);
4048: SLJIT_ASSERT(localptr != 0);
4049: FALLBACK_AS(bracket_fallback)->localptr = localptr;
4050: if (opcode == OP_ONCE)
4051: FALLBACK_AS(bracket_fallback)->u.framesize = get_framesize(common, ccbegin, FALSE);
4052: }
4053:
4054: /* Instructions before the first alternative. */
4055: stacksize = 0;
4056: if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
4057: stacksize++;
4058: if (bra == OP_BRAZERO)
4059: stacksize++;
4060:
4061: if (stacksize > 0)
4062: allocate_stack(common, stacksize);
4063:
4064: stacksize = 0;
4065: if ((ket == OP_KETRMAX) || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
4066: {
4067: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
4068: stacksize++;
4069: }
4070:
4071: if (bra == OP_BRAZERO)
4072: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
4073:
4074: if (bra == OP_BRAMINZERO)
4075: {
4076: /* This is a fallback path! (Since the hot-path of OP_BRAMINZERO matches to the empty string) */
4077: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
4078: if (ket != OP_KETRMIN)
4079: {
4080: free_stack(common, 1);
4081: braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
4082: }
4083: else
4084: {
4085: if (opcode == OP_ONCE || opcode >= OP_SBRA)
4086: {
4087: jump = CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
4088: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
4089: /* Nothing stored during the first run. */
4090: skip = JUMP(SLJIT_JUMP);
4091: JUMPHERE(jump);
4092: /* Checking zero-length iteration. */
4093: if (opcode != OP_ONCE || FALLBACK_AS(bracket_fallback)->u.framesize < 0)
4094: {
4095: /* When we come from outside, localptr contains the previous STR_PTR. */
4096: braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4097: }
4098: else
4099: {
4100: /* Except when the whole stack frame must be saved. */
4101: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4102: braminzerojump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (FALLBACK_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w));
4103: }
4104: JUMPHERE(skip);
4105: }
4106: else
4107: {
4108: jump = CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
4109: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
4110: JUMPHERE(jump);
4111: }
4112: }
4113: }
4114:
4115: if (ket == OP_KETRMIN)
4116: FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();
4117:
4118: if (ket == OP_KETRMAX)
4119: {
4120: rmaxlabel = LABEL();
4121: if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA)
4122: FALLBACK_AS(bracket_fallback)->althotpath = rmaxlabel;
4123: }
4124:
4125: /* Handling capturing brackets and alternatives. */
4126: if (opcode == OP_ONCE)
4127: {
4128: if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)
4129: {
4130: /* Neither capturing brackets nor recursions are not found in the block. */
4131: if (ket == OP_KETRMIN)
4132: {
4133: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4134: allocate_stack(common, 2);
4135: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4136: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
4137: OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
4138: }
4139: else if (ket == OP_KETRMAX || has_alternatives)
4140: {
4141: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);
4142: allocate_stack(common, 1);
4143: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4144: }
4145: else
4146: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);
4147: }
4148: else
4149: {
4150: if (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives)
4151: {
4152: allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 2);
4153: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4154: OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize + 1));
4155: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4156: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
4157: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
4158: init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize + 1, 2, FALSE);
4159: }
4160: else
4161: {
4162: allocate_stack(common, FALLBACK_AS(bracket_fallback)->u.framesize + 1);
4163: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4164: OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(FALLBACK_AS(bracket_fallback)->u.framesize));
4165: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
4166: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
4167: init_frame(common, ccbegin, FALLBACK_AS(bracket_fallback)->u.framesize, 1, FALSE);
4168: }
4169: }
4170: }
4171: else if (opcode == OP_CBRA || opcode == OP_SCBRA)
4172: {
4173: /* Saving the previous values. */
4174: allocate_stack(common, 3);
4175: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
4176: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
4177: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
4178: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
4179: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4180: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0);
4181: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
4182: }
4183: else if (opcode == OP_SBRA || opcode == OP_SCOND)
4184: {
4185: /* Saving the previous value. */
4186: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4187: allocate_stack(common, 1);
4188: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0);
4189: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
4190: }
4191: else if (has_alternatives)
4192: {
4193: /* Pushing the starting string pointer. */
4194: allocate_stack(common, 1);
4195: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4196: }
4197:
4198: /* Generating code for the first alternative. */
4199: if (opcode == OP_COND || opcode == OP_SCOND)
4200: {
4201: if (*hotpath == OP_CREF)
4202: {
4203: SLJIT_ASSERT(has_alternatives);
4204: add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed),
4205: CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(hotpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));
4206: hotpath += 3;
4207: }
4208: else if (*hotpath == OP_NCREF)
4209: {
4210: SLJIT_ASSERT(has_alternatives);
4211: stacksize = GET2(hotpath, 1);
4212: jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(stacksize << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
4213:
4214: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
4215: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
4216: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
4217: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
4218: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
4219: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
4220: sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchovector));
4221: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
4222: add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
4223:
4224: JUMPHERE(jump);
4225: hotpath += 3;
4226: }
4227: else if (*hotpath == OP_RREF || *hotpath == OP_NRREF)
4228: {
4229: /* Never has other case. */
4230: FALLBACK_AS(bracket_fallback)->u.condfailed = NULL;
4231:
4232: stacksize = GET2(hotpath, 1);
4233: if (common->currententry == NULL)
4234: stacksize = 0;
4235: else if (stacksize == RREF_ANY)
4236: stacksize = 1;
4237: else if (common->currententry->start == 0)
4238: stacksize = stacksize == 0;
4239: else
4240: stacksize = stacksize == GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
4241:
4242: if (*hotpath == OP_RREF || stacksize || common->currententry == NULL)
4243: {
4244: SLJIT_ASSERT(!has_alternatives);
4245: if (stacksize != 0)
4246: hotpath += 3;
4247: else
4248: {
4249: if (*cc == OP_ALT)
4250: {
4251: hotpath = cc + 1 + LINK_SIZE;
4252: cc += GET(cc, 1);
4253: }
4254: else
4255: hotpath = cc;
4256: }
4257: }
4258: else
4259: {
4260: SLJIT_ASSERT(has_alternatives);
4261:
4262: stacksize = GET2(hotpath, 1);
4263: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STACK_TOP, 0);
4264: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, SLJIT_IMM, common->name_count);
4265: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, common->name_entry_size);
4266: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, GET2(common->start, common->currententry->start + 1 + LINK_SIZE));
4267: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, stacksize);
4268: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG2, 0, SLJIT_LOCALS_REG, 0);
4269: OP1(SLJIT_MOV, SLJIT_TEMPORARY_REG3, 0, SLJIT_IMM, common->name_table);
4270: sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_searchgroups));
4271: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
4272: add_jump(compiler, &(FALLBACK_AS(bracket_fallback)->u.condfailed), CMP(SLJIT_C_EQUAL, SLJIT_TEMPORARY_REG1, 0, SLJIT_IMM, 0));
4273: hotpath += 3;
4274: }
4275: }
4276: else
4277: {
4278: SLJIT_ASSERT(has_alternatives && *hotpath >= OP_ASSERT && *hotpath <= OP_ASSERTBACK_NOT);
4279: /* Similar code as PUSH_FALLBACK macro. */
4280: assert = sljit_alloc_memory(compiler, sizeof(assert_fallback));
4281: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
4282: return NULL;
4283: memset(assert, 0, sizeof(assert_fallback));
4284: assert->common.cc = hotpath;
4285: FALLBACK_AS(bracket_fallback)->u.assert = assert;
4286: hotpath = compile_assert_hotpath(common, hotpath, assert, TRUE);
4287: }
4288: }
4289:
4290: compile_hotpath(common, hotpath, cc, fallback);
4291: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
4292: return NULL;
4293:
4294: if (opcode == OP_ONCE)
4295: {
4296: if (FALLBACK_AS(bracket_fallback)->u.framesize < 0)
4297: {
4298: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4299: /* TMP2 which is set here used by OP_KETRMAX below. */
4300: if (ket == OP_KETRMAX)
4301: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
4302: else if (ket == OP_KETRMIN)
4303: {
4304: /* Move the STR_PTR to the localptr. */
4305: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), 0);
4306: }
4307: }
4308: else
4309: {
4310: stacksize = (ket == OP_KETRMIN || ket == OP_KETRMAX || has_alternatives) ? 2 : 1;
4311: OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (FALLBACK_AS(bracket_fallback)->u.framesize + stacksize) * sizeof(sljit_w));
4312: if (ket == OP_KETRMAX)
4313: {
4314: /* TMP2 which is set here used by OP_KETRMAX below. */
4315: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
4316: }
4317: }
4318: }
4319:
4320: stacksize = 0;
4321: if (ket != OP_KET || bra != OP_BRA)
4322: stacksize++;
4323: if (has_alternatives && opcode != OP_ONCE)
4324: stacksize++;
4325:
4326: if (stacksize > 0)
4327: allocate_stack(common, stacksize);
4328:
4329: stacksize = 0;
4330: if (ket != OP_KET)
4331: {
4332: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
4333: stacksize++;
4334: }
4335: else if (bra != OP_BRA)
4336: {
4337: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
4338: stacksize++;
4339: }
4340:
4341: if (has_alternatives)
4342: {
4343: if (opcode != OP_ONCE)
4344: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
4345: if (ket != OP_KETRMAX)
4346: FALLBACK_AS(bracket_fallback)->althotpath = LABEL();
4347: }
4348:
4349: /* Must be after the hotpath label. */
4350: if (offset != 0)
4351: {
4352: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4353: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
4354: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 0), TMP1, 0);
4355: }
4356:
4357: if (ket == OP_KETRMAX)
4358: {
4359: if (opcode == OP_ONCE || opcode >= OP_SBRA)
4360: {
4361: if (has_alternatives)
4362: FALLBACK_AS(bracket_fallback)->althotpath = LABEL();
4363: /* Checking zero-length iteration. */
4364: if (opcode != OP_ONCE)
4365: CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STR_PTR, 0, rmaxlabel);
4366: else
4367: /* TMP2 must contain the starting STR_PTR. */
4368: CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmaxlabel);
4369: }
4370: else
4371: JUMPTO(SLJIT_JUMP, rmaxlabel);
4372: FALLBACK_AS(bracket_fallback)->recursivehotpath = LABEL();
4373: }
4374:
4375: if (bra == OP_BRAZERO)
4376: FALLBACK_AS(bracket_fallback)->zerohotpath = LABEL();
4377:
4378: if (bra == OP_BRAMINZERO)
4379: {
4380: /* This is a fallback path! (From the viewpoint of OP_BRAMINZERO) */
4381: JUMPTO(SLJIT_JUMP, ((braminzero_fallback*)parent)->hotpath);
4382: if (braminzerojump != NULL)
4383: {
4384: JUMPHERE(braminzerojump);
4385: /* We need to release the end pointer to perform the
4386: fallback for the zero-length iteration. When
4387: framesize is < 0, OP_ONCE will do the release itself. */
4388: if (opcode == OP_ONCE && FALLBACK_AS(bracket_fallback)->u.framesize >= 0)
4389: {
4390: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4391: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
4392: }
4393: else if (ket == OP_KETRMIN && opcode != OP_ONCE)
4394: free_stack(common, 1);
4395: }
4396: /* Continue to the normal fallback. */
4397: }
4398:
4399: if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)
4400: decrease_call_count(common);
4401:
4402: /* Skip the other alternatives. */
4403: while (*cc == OP_ALT)
4404: cc += GET(cc, 1);
4405: cc += 1 + LINK_SIZE;
4406: return cc;
4407: }
4408:
4409: static uschar *compile_bracketpos_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
4410: {
4411: DEFINE_COMPILER;
4412: fallback_common *fallback;
4413: uschar opcode;
4414: int localptr;
4415: int cbraprivptr = 0;
4416: int framesize;
4417: int stacksize;
4418: int offset = 0;
4419: BOOL zero = FALSE;
4420: uschar *ccbegin = NULL;
4421: int stack;
4422: struct sljit_label *loop = NULL;
4423: struct jump_list *emptymatch = NULL;
4424:
4425: PUSH_FALLBACK(sizeof(bracketpos_fallback), cc, NULL);
4426: if (*cc == OP_BRAPOSZERO)
4427: {
4428: zero = TRUE;
4429: cc++;
4430: }
4431:
4432: opcode = *cc;
4433: localptr = PRIV(cc);
4434: SLJIT_ASSERT(localptr != 0);
4435: FALLBACK_AS(bracketpos_fallback)->localptr = localptr;
4436: switch(opcode)
4437: {
4438: case OP_BRAPOS:
4439: case OP_SBRAPOS:
4440: ccbegin = cc + 1 + LINK_SIZE;
4441: break;
4442:
4443: case OP_CBRAPOS:
4444: case OP_SCBRAPOS:
4445: offset = GET2(cc, 1 + LINK_SIZE);
4446: cbraprivptr = OVECTOR_PRIV(offset);
4447: offset <<= 1;
4448: ccbegin = cc + 1 + LINK_SIZE + 2;
4449: break;
4450:
4451: default:
4452: SLJIT_ASSERT_STOP();
4453: break;
4454: }
4455:
4456: framesize = get_framesize(common, cc, FALSE);
4457: FALLBACK_AS(bracketpos_fallback)->framesize = framesize;
4458: if (framesize < 0)
4459: {
4460: stacksize = (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS) ? 2 : 1;
4461: if (!zero)
4462: stacksize++;
4463: FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;
4464: allocate_stack(common, stacksize);
4465: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, STACK_TOP, 0);
4466:
4467: if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
4468: {
4469: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));
4470: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));
4471: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
4472: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
4473: }
4474: else
4475: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4476:
4477: if (!zero)
4478: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 1);
4479: }
4480: else
4481: {
4482: stacksize = framesize + 1;
4483: if (!zero)
4484: stacksize++;
4485: if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)
4486: stacksize++;
4487: FALLBACK_AS(bracketpos_fallback)->stacksize = stacksize;
4488: allocate_stack(common, stacksize);
4489:
4490: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4491: OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));
4492: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP2, 0);
4493: stack = 0;
4494: if (!zero)
4495: {
4496: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);
4497: stack++;
4498: }
4499: if (opcode == OP_BRAPOS || opcode == OP_SBRAPOS)
4500: {
4501: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);
4502: stack++;
4503: }
4504: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);
4505: init_frame(common, cc, stacksize - 1, stacksize - framesize, FALSE);
4506: }
4507:
4508: if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
4509: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
4510:
4511: loop = LABEL();
4512: while (*cc != OP_KETRPOS)
4513: {
4514: fallback->top = NULL;
4515: fallback->topfallbacks = NULL;
4516: cc += GET(cc, 1);
4517:
4518: compile_hotpath(common, ccbegin, cc, fallback);
4519: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
4520: return NULL;
4521:
4522: if (framesize < 0)
4523: {
4524: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4525:
4526: if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
4527: {
4528: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
4529: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
4530: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
4531: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
4532: }
4533: else
4534: {
4535: if (opcode == OP_SBRAPOS)
4536: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
4537: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4538: }
4539:
4540: if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)
4541: add_jump(compiler, &emptymatch, CMP(SLJIT_C_EQUAL, TMP1, 0, STR_PTR, 0));
4542:
4543: if (!zero)
4544: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);
4545: }
4546: else
4547: {
4548: if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
4549: {
4550: OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, stacksize * sizeof(sljit_w));
4551: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
4552: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
4553: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);
4554: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
4555: }
4556: else
4557: {
4558: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4559: OP2(SLJIT_ADD, STACK_TOP, 0, TMP2, 0, SLJIT_IMM, stacksize * sizeof(sljit_w));
4560: if (opcode == OP_SBRAPOS)
4561: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w));
4562: OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w), STR_PTR, 0);
4563: }
4564:
4565: if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)
4566: add_jump(compiler, &emptymatch, CMP(SLJIT_C_EQUAL, TMP1, 0, STR_PTR, 0));
4567:
4568: if (!zero)
4569: {
4570: if (framesize < 0)
4571: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);
4572: else
4573: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
4574: }
4575: }
4576: JUMPTO(SLJIT_JUMP, loop);
4577: flush_stubs(common);
4578:
4579: compile_fallbackpath(common, fallback->top);
4580: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
4581: return NULL;
4582: set_jumps(fallback->topfallbacks, LABEL());
4583:
4584: if (framesize < 0)
4585: {
4586: if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
4587: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
4588: else
4589: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
4590: }
4591: else
4592: {
4593: if (opcode == OP_CBRAPOS || opcode == OP_SCBRAPOS)
4594: {
4595: /* Last alternative. */
4596: if (*cc == OP_KETRPOS)
4597: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4598: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);
4599: }
4600: else
4601: {
4602: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
4603: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_w));
4604: }
4605: }
4606:
4607: if (*cc == OP_KETRPOS)
4608: break;
4609: ccbegin = cc + 1 + LINK_SIZE;
4610: }
4611:
4612: fallback->topfallbacks = NULL;
4613: if (!zero)
4614: {
4615: if (framesize < 0)
4616: add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));
4617: else /* TMP2 is set to [localptr] above. */
4618: add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_w), SLJIT_IMM, 0));
4619: }
4620:
4621: /* None of them matched. */
4622: set_jumps(emptymatch, LABEL());
4623: decrease_call_count(common);
4624: return cc + 1 + LINK_SIZE;
4625: }
4626:
4627: static SLJIT_INLINE uschar *get_iterator_parameters(compiler_common *common, uschar *cc, uschar *opcode, uschar *type, int *arg1, int *arg2, uschar **end)
4628: {
4629: int class_len;
4630:
4631: *opcode = *cc;
4632: if (*opcode >= OP_STAR && *opcode <= OP_POSUPTO)
4633: {
4634: cc++;
4635: *type = OP_CHAR;
4636: }
4637: else if (*opcode >= OP_STARI && *opcode <= OP_POSUPTOI)
4638: {
4639: cc++;
4640: *type = OP_CHARI;
4641: *opcode -= OP_STARI - OP_STAR;
4642: }
4643: else if (*opcode >= OP_NOTSTAR && *opcode <= OP_NOTPOSUPTO)
4644: {
4645: cc++;
4646: *type = OP_NOT;
4647: *opcode -= OP_NOTSTAR - OP_STAR;
4648: }
4649: else if (*opcode >= OP_NOTSTARI && *opcode <= OP_NOTPOSUPTOI)
4650: {
4651: cc++;
4652: *type = OP_NOTI;
4653: *opcode -= OP_NOTSTARI - OP_STAR;
4654: }
4655: else if (*opcode >= OP_TYPESTAR && *opcode <= OP_TYPEPOSUPTO)
4656: {
4657: cc++;
4658: *opcode -= OP_TYPESTAR - OP_STAR;
4659: *type = 0;
4660: }
4661: else
4662: {
4663: SLJIT_ASSERT(*opcode >= OP_CLASS || *opcode <= OP_XCLASS);
4664: *type = *opcode;
4665: cc++;
4666: class_len = (*type < OP_XCLASS) ? 33 : GET(cc, 0);
4667: *opcode = cc[class_len - 1];
4668: if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)
4669: {
4670: *opcode -= OP_CRSTAR - OP_STAR;
4671: if (end != NULL)
4672: *end = cc + class_len;
4673: }
4674: else
4675: {
4676: SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE);
4677: *arg1 = GET2(cc, (class_len + 2));
4678: *arg2 = GET2(cc, class_len);
4679:
4680: if (*arg2 == 0)
4681: {
4682: SLJIT_ASSERT(*arg1 != 0);
4683: *opcode = (*opcode == OP_CRRANGE) ? OP_UPTO : OP_MINUPTO;
4684: }
4685: if (*arg1 == *arg2)
4686: *opcode = OP_EXACT;
4687:
4688: if (end != NULL)
4689: *end = cc + class_len + 4;
4690: }
4691: return cc;
4692: }
4693:
4694: if (*opcode == OP_UPTO || *opcode == OP_MINUPTO || *opcode == OP_EXACT || *opcode == OP_POSUPTO)
4695: {
4696: *arg1 = GET2(cc, 0);
4697: cc += 2;
4698: }
4699:
4700: if (*type == 0)
4701: {
4702: *type = *cc;
4703: if (end != NULL)
4704: *end = next_opcode(common, cc);
4705: cc++;
4706: return cc;
4707: }
4708:
4709: if (end != NULL)
4710: {
4711: *end = cc + 1;
4712: #ifdef SUPPORT_UTF8
4713: if (common->utf8 && *cc >= 0xc0) *end += _pcre_utf8_table4[*cc & 0x3f];
4714: #endif
4715: }
4716: return cc;
4717: }
4718:
4719: static uschar *compile_iterator_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
4720: {
4721: DEFINE_COMPILER;
4722: fallback_common *fallback;
4723: uschar opcode;
4724: uschar type;
4725: int arg1 = -1, arg2 = -1;
4726: uschar* end;
4727: jump_list *nomatch = NULL;
4728: struct sljit_jump *jump = NULL;
4729: struct sljit_label *label;
4730:
4731: PUSH_FALLBACK(sizeof(iterator_fallback), cc, NULL);
4732:
4733: cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, &end);
4734:
4735: switch(opcode)
4736: {
4737: case OP_STAR:
4738: case OP_PLUS:
4739: case OP_UPTO:
4740: case OP_CRRANGE:
4741: if (type == OP_ANYNL || type == OP_EXTUNI)
4742: {
4743: if (opcode == OP_STAR || opcode == OP_UPTO)
4744: {
4745: allocate_stack(common, 2);
4746: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4747: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
4748: }
4749: else
4750: {
4751: allocate_stack(common, 1);
4752: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
4753: }
4754: if (opcode == OP_UPTO || opcode == OP_CRRANGE)
4755: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);
4756:
4757: label = LABEL();
4758: compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
4759: if (opcode == OP_UPTO || opcode == OP_CRRANGE)
4760: {
4761: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
4762: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
4763: if (opcode == OP_CRRANGE && arg2 > 0)
4764: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg2, label);
4765: if (opcode == OP_UPTO || (opcode == OP_CRRANGE && arg1 > 0))
4766: jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, arg1);
4767: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
4768: }
4769:
4770: allocate_stack(common, 1);
4771: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4772: JUMPTO(SLJIT_JUMP, label);
4773: if (jump != NULL)
4774: JUMPHERE(jump);
4775: }
4776: else
4777: {
4778: allocate_stack(common, 2);
4779: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4780: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
4781: label = LABEL();
4782: compile_char1_hotpath(common, type, cc, &nomatch);
4783: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4784: if (opcode <= OP_PLUS || (opcode == OP_CRRANGE && arg1 == 0))
4785: {
4786: OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
4787: JUMPTO(SLJIT_JUMP, label);
4788: }
4789: else
4790: {
4791: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
4792: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
4793: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
4794: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);
4795: }
4796: set_jumps(nomatch, LABEL());
4797: if (opcode == OP_PLUS || opcode == OP_CRRANGE)
4798: add_jump(compiler, &fallback->topfallbacks,
4799: CMP(SLJIT_C_LESS, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, opcode == OP_PLUS ? 2 : arg2 + 1));
4800: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
4801: }
4802: FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
4803: break;
4804:
4805: case OP_MINSTAR:
4806: case OP_MINPLUS:
4807: allocate_stack(common, 1);
4808: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4809: if (opcode == OP_MINPLUS)
4810: add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
4811: FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
4812: break;
4813:
4814: case OP_MINUPTO:
4815: case OP_CRMINRANGE:
4816: allocate_stack(common, 2);
4817: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4818: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
4819: if (opcode == OP_CRMINRANGE)
4820: add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
4821: FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
4822: break;
4823:
4824: case OP_QUERY:
4825: case OP_MINQUERY:
4826: allocate_stack(common, 1);
4827: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
4828: if (opcode == OP_QUERY)
4829: compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
4830: FALLBACK_AS(iterator_fallback)->hotpath = LABEL();
4831: break;
4832:
4833: case OP_EXACT:
4834: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);
4835: label = LABEL();
4836: compile_char1_hotpath(common, type, cc, &fallback->topfallbacks);
4837: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
4838: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
4839: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
4840: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);
4841: break;
4842:
4843: case OP_POSSTAR:
4844: case OP_POSPLUS:
4845: case OP_POSUPTO:
4846: if (opcode != OP_POSSTAR)
4847: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 1);
4848: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
4849: label = LABEL();
4850: compile_char1_hotpath(common, type, cc, &nomatch);
4851: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
4852: if (opcode != OP_POSUPTO)
4853: {
4854: if (opcode == OP_POSPLUS)
4855: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2);
4856: JUMPTO(SLJIT_JUMP, label);
4857: }
4858: else
4859: {
4860: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);
4861: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
4862: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);
4863: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 1, label);
4864: }
4865: set_jumps(nomatch, LABEL());
4866: if (opcode == OP_POSPLUS)
4867: add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_LESS, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 2));
4868: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
4869: break;
4870:
4871: case OP_POSQUERY:
4872: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
4873: compile_char1_hotpath(common, type, cc, &nomatch);
4874: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, STR_PTR, 0);
4875: set_jumps(nomatch, LABEL());
4876: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);
4877: break;
4878:
4879: default:
4880: SLJIT_ASSERT_STOP();
4881: break;
4882: }
4883:
4884: decrease_call_count(common);
4885: return end;
4886: }
4887:
4888: static SLJIT_INLINE uschar *compile_fail_accept_hotpath(compiler_common *common, uschar *cc, fallback_common *parent)
4889: {
4890: DEFINE_COMPILER;
4891: fallback_common *fallback;
4892:
4893: PUSH_FALLBACK(sizeof(bracket_fallback), cc, NULL);
4894:
4895: if (*cc == OP_FAIL)
4896: {
4897: add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
4898: return cc + 1;
4899: }
4900:
4901: if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL)
4902: {
4903: /* No need to check notempty conditions. */
4904: if (common->acceptlabel == NULL)
4905: add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
4906: else
4907: JUMPTO(SLJIT_JUMP, common->acceptlabel);
4908: return cc + 1;
4909: }
4910:
4911: if (common->acceptlabel == NULL)
4912: add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0)));
4913: else
4914: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), common->acceptlabel);
4915: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
4916: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
4917: add_jump(compiler, &fallback->topfallbacks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
4918: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
4919: if (common->acceptlabel == NULL)
4920: add_jump(compiler, &common->accept, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0));
4921: else
4922: CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->acceptlabel);
4923: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
4924: if (common->acceptlabel == NULL)
4925: add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0));
4926: else
4927: CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->acceptlabel);
4928: add_jump(compiler, &fallback->topfallbacks, JUMP(SLJIT_JUMP));
4929: return cc + 1;
4930: }
4931:
4932: static SLJIT_INLINE uschar *compile_close_hotpath(compiler_common *common, uschar *cc)
4933: {
4934: DEFINE_COMPILER;
4935: int offset = GET2(cc, 1);
4936:
4937: /* Data will be discarded anyway... */
4938: if (common->currententry != NULL)
4939: return cc + 3;
4940:
4941: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR_PRIV(offset));
4942: offset <<= 1;
4943: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
4944: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
4945: return cc + 3;
4946: }
4947:
4948: static void compile_hotpath(compiler_common *common, uschar *cc, uschar *ccend, fallback_common *parent)
4949: {
4950: DEFINE_COMPILER;
4951: fallback_common *fallback;
4952:
4953: while (cc < ccend)
4954: {
4955: switch(*cc)
4956: {
4957: case OP_SOD:
4958: case OP_SOM:
4959: case OP_NOT_WORD_BOUNDARY:
4960: case OP_WORD_BOUNDARY:
4961: case OP_NOT_DIGIT:
4962: case OP_DIGIT:
4963: case OP_NOT_WHITESPACE:
4964: case OP_WHITESPACE:
4965: case OP_NOT_WORDCHAR:
4966: case OP_WORDCHAR:
4967: case OP_ANY:
4968: case OP_ALLANY:
4969: case OP_ANYBYTE:
4970: case OP_NOTPROP:
4971: case OP_PROP:
4972: case OP_ANYNL:
4973: case OP_NOT_HSPACE:
4974: case OP_HSPACE:
4975: case OP_NOT_VSPACE:
4976: case OP_VSPACE:
4977: case OP_EXTUNI:
4978: case OP_EODN:
4979: case OP_EOD:
4980: case OP_CIRC:
4981: case OP_CIRCM:
4982: case OP_DOLL:
4983: case OP_DOLLM:
4984: case OP_NOT:
4985: case OP_NOTI:
4986: case OP_REVERSE:
4987: cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
4988: break;
4989:
4990: case OP_SET_SOM:
4991: PUSH_FALLBACK_NOVALUE(sizeof(fallback_common), cc);
4992: allocate_stack(common, 1);
4993: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
4994: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);
4995: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
4996: cc++;
4997: break;
4998:
4999: case OP_CHAR:
5000: case OP_CHARI:
5001: cc = compile_charn_hotpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
5002: break;
5003:
5004: case OP_STAR:
5005: case OP_MINSTAR:
5006: case OP_PLUS:
5007: case OP_MINPLUS:
5008: case OP_QUERY:
5009: case OP_MINQUERY:
5010: case OP_UPTO:
5011: case OP_MINUPTO:
5012: case OP_EXACT:
5013: case OP_POSSTAR:
5014: case OP_POSPLUS:
5015: case OP_POSQUERY:
5016: case OP_POSUPTO:
5017: case OP_STARI:
5018: case OP_MINSTARI:
5019: case OP_PLUSI:
5020: case OP_MINPLUSI:
5021: case OP_QUERYI:
5022: case OP_MINQUERYI:
5023: case OP_UPTOI:
5024: case OP_MINUPTOI:
5025: case OP_EXACTI:
5026: case OP_POSSTARI:
5027: case OP_POSPLUSI:
5028: case OP_POSQUERYI:
5029: case OP_POSUPTOI:
5030: case OP_NOTSTAR:
5031: case OP_NOTMINSTAR:
5032: case OP_NOTPLUS:
5033: case OP_NOTMINPLUS:
5034: case OP_NOTQUERY:
5035: case OP_NOTMINQUERY:
5036: case OP_NOTUPTO:
5037: case OP_NOTMINUPTO:
5038: case OP_NOTEXACT:
5039: case OP_NOTPOSSTAR:
5040: case OP_NOTPOSPLUS:
5041: case OP_NOTPOSQUERY:
5042: case OP_NOTPOSUPTO:
5043: case OP_NOTSTARI:
5044: case OP_NOTMINSTARI:
5045: case OP_NOTPLUSI:
5046: case OP_NOTMINPLUSI:
5047: case OP_NOTQUERYI:
5048: case OP_NOTMINQUERYI:
5049: case OP_NOTUPTOI:
5050: case OP_NOTMINUPTOI:
5051: case OP_NOTEXACTI:
5052: case OP_NOTPOSSTARI:
5053: case OP_NOTPOSPLUSI:
5054: case OP_NOTPOSQUERYI:
5055: case OP_NOTPOSUPTOI:
5056: case OP_TYPESTAR:
5057: case OP_TYPEMINSTAR:
5058: case OP_TYPEPLUS:
5059: case OP_TYPEMINPLUS:
5060: case OP_TYPEQUERY:
5061: case OP_TYPEMINQUERY:
5062: case OP_TYPEUPTO:
5063: case OP_TYPEMINUPTO:
5064: case OP_TYPEEXACT:
5065: case OP_TYPEPOSSTAR:
5066: case OP_TYPEPOSPLUS:
5067: case OP_TYPEPOSQUERY:
5068: case OP_TYPEPOSUPTO:
5069: cc = compile_iterator_hotpath(common, cc, parent);
5070: break;
5071:
5072: case OP_CLASS:
5073: case OP_NCLASS:
5074: if (cc[33] >= OP_CRSTAR && cc[33] <= OP_CRMINRANGE)
5075: cc = compile_iterator_hotpath(common, cc, parent);
5076: else
5077: cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
5078: break;
5079:
5080: #ifdef SUPPORT_UTF8
5081: case OP_XCLASS:
5082: if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRMINRANGE)
5083: cc = compile_iterator_hotpath(common, cc, parent);
5084: else
5085: cc = compile_char1_hotpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks);
5086: break;
5087: #endif
5088:
5089: case OP_REF:
5090: case OP_REFI:
5091: if (cc[3] >= OP_CRSTAR && cc[3] <= OP_CRMINRANGE)
5092: cc = compile_ref_iterator_hotpath(common, cc, parent);
5093: else
5094: cc = compile_ref_hotpath(common, cc, parent->top != NULL ? &parent->top->nextfallbacks : &parent->topfallbacks, TRUE, FALSE);
5095: break;
5096:
5097: case OP_RECURSE:
5098: cc = compile_recurse_hotpath(common, cc, parent);
5099: break;
5100:
5101: case OP_ASSERT:
5102: case OP_ASSERT_NOT:
5103: case OP_ASSERTBACK:
5104: case OP_ASSERTBACK_NOT:
5105: PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);
5106: cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
5107: break;
5108:
5109: case OP_BRAMINZERO:
5110: PUSH_FALLBACK_NOVALUE(sizeof(braminzero_fallback), cc);
5111: cc = bracketend(cc + 1);
5112: if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)
5113: {
5114: allocate_stack(common, 1);
5115: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5116: }
5117: else
5118: {
5119: allocate_stack(common, 2);
5120: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5121: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);
5122: }
5123: FALLBACK_AS(braminzero_fallback)->hotpath = LABEL();
5124: if (cc[1] > OP_ASSERTBACK_NOT)
5125: decrease_call_count(common);
5126: break;
5127:
5128: case OP_ONCE:
5129: case OP_ONCE_NC:
5130: case OP_BRA:
5131: case OP_CBRA:
5132: case OP_COND:
5133: case OP_SBRA:
5134: case OP_SCBRA:
5135: case OP_SCOND:
5136: cc = compile_bracket_hotpath(common, cc, parent);
5137: break;
5138:
5139: case OP_BRAZERO:
5140: if (cc[1] > OP_ASSERTBACK_NOT)
5141: cc = compile_bracket_hotpath(common, cc, parent);
5142: else
5143: {
5144: PUSH_FALLBACK_NOVALUE(sizeof(assert_fallback), cc);
5145: cc = compile_assert_hotpath(common, cc, FALLBACK_AS(assert_fallback), FALSE);
5146: }
5147: break;
5148:
5149: case OP_BRAPOS:
5150: case OP_CBRAPOS:
5151: case OP_SBRAPOS:
5152: case OP_SCBRAPOS:
5153: case OP_BRAPOSZERO:
5154: cc = compile_bracketpos_hotpath(common, cc, parent);
5155: break;
5156:
5157: case OP_FAIL:
5158: case OP_ACCEPT:
5159: case OP_ASSERT_ACCEPT:
5160: cc = compile_fail_accept_hotpath(common, cc, parent);
5161: break;
5162:
5163: case OP_CLOSE:
5164: cc = compile_close_hotpath(common, cc);
5165: break;
5166:
5167: case OP_SKIPZERO:
5168: cc = bracketend(cc + 1);
5169: break;
5170:
5171: default:
5172: SLJIT_ASSERT_STOP();
5173: return;
5174: }
5175: if (cc == NULL)
5176: return;
5177: }
5178: SLJIT_ASSERT(cc == ccend);
5179: }
5180:
5181: #undef PUSH_FALLBACK
5182: #undef PUSH_FALLBACK_NOVALUE
5183: #undef FALLBACK_AS
5184:
5185: #define COMPILE_FALLBACKPATH(current) \
5186: do \
5187: { \
5188: compile_fallbackpath(common, (current)); \
5189: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
5190: return; \
5191: } \
5192: while (0)
5193:
5194: #define CURRENT_AS(type) ((type*)current)
5195:
5196: static void compile_iterator_fallbackpath(compiler_common *common, struct fallback_common *current)
5197: {
5198: DEFINE_COMPILER;
5199: uschar *cc = current->cc;
5200: uschar opcode;
5201: uschar type;
5202: int arg1 = -1, arg2 = -1;
5203: struct sljit_label *label = NULL;
5204: struct sljit_jump *jump = NULL;
5205:
5206: cc = get_iterator_parameters(common, cc, &opcode, &type, &arg1, &arg2, NULL);
5207:
5208: switch(opcode)
5209: {
5210: case OP_STAR:
5211: case OP_PLUS:
5212: case OP_UPTO:
5213: case OP_CRRANGE:
5214: if (type == OP_ANYNL || type == OP_EXTUNI)
5215: {
5216: set_jumps(current->topfallbacks, LABEL());
5217: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5218: free_stack(common, 1);
5219: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
5220: }
5221: else
5222: {
5223: if (opcode == OP_STAR || opcode == OP_UPTO)
5224: arg2 = 0;
5225: else if (opcode == OP_PLUS)
5226: arg2 = 1;
5227: jump = CMP(SLJIT_C_LESS_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, arg2 + 1);
5228: OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
5229: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5230: skip_char_back(common);
5231: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5232: JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
5233: if (opcode == OP_PLUS || opcode == OP_CRRANGE)
5234: set_jumps(current->topfallbacks, LABEL());
5235: JUMPHERE(jump);
5236: free_stack(common, 2);
5237: }
5238: break;
5239:
5240: case OP_MINSTAR:
5241: case OP_MINPLUS:
5242: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5243: if (opcode == OP_MINPLUS)
5244: {
5245: set_jumps(current->topfallbacks, LABEL());
5246: current->topfallbacks = NULL;
5247: }
5248: compile_char1_hotpath(common, type, cc, ¤t->topfallbacks);
5249: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5250: JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
5251: set_jumps(current->topfallbacks, LABEL());
5252: free_stack(common, 1);
5253: break;
5254:
5255: case OP_MINUPTO:
5256: case OP_CRMINRANGE:
5257: if (opcode == OP_CRMINRANGE)
5258: {
5259: set_jumps(current->topfallbacks, LABEL());
5260: current->topfallbacks = NULL;
5261: label = LABEL();
5262: }
5263: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5264: compile_char1_hotpath(common, type, cc, ¤t->topfallbacks);
5265:
5266: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
5267: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
5268: OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
5269: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
5270:
5271: if (opcode == OP_CRMINRANGE)
5272: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg2 + 1, label);
5273:
5274: if (opcode == OP_CRMINRANGE && arg1 == 0)
5275: JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
5276: else
5277: CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, arg1 + 2, CURRENT_AS(iterator_fallback)->hotpath);
5278:
5279: set_jumps(current->topfallbacks, LABEL());
5280: free_stack(common, 2);
5281: break;
5282:
5283: case OP_QUERY:
5284: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5285: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5286: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
5287: jump = JUMP(SLJIT_JUMP);
5288: set_jumps(current->topfallbacks, LABEL());
5289: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5290: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5291: JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
5292: JUMPHERE(jump);
5293: free_stack(common, 1);
5294: break;
5295:
5296: case OP_MINQUERY:
5297: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5298: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5299: jump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
5300: compile_char1_hotpath(common, type, cc, ¤t->topfallbacks);
5301: JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_fallback)->hotpath);
5302: set_jumps(current->topfallbacks, LABEL());
5303: JUMPHERE(jump);
5304: free_stack(common, 1);
5305: break;
5306:
5307: case OP_EXACT:
5308: case OP_POSPLUS:
5309: set_jumps(current->topfallbacks, LABEL());
5310: break;
5311:
5312: case OP_POSSTAR:
5313: case OP_POSQUERY:
5314: case OP_POSUPTO:
5315: break;
5316:
5317: default:
5318: SLJIT_ASSERT_STOP();
5319: break;
5320: }
5321: }
5322:
5323: static void compile_ref_iterator_fallbackpath(compiler_common *common, struct fallback_common *current)
5324: {
5325: DEFINE_COMPILER;
5326: uschar *cc = current->cc;
5327: uschar type;
5328:
5329: type = cc[3];
5330: if ((type & 0x1) == 0)
5331: {
5332: set_jumps(current->topfallbacks, LABEL());
5333: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5334: free_stack(common, 1);
5335: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
5336: return;
5337: }
5338:
5339: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5340: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_fallback)->hotpath);
5341: set_jumps(current->topfallbacks, LABEL());
5342: free_stack(common, 2);
5343: }
5344:
5345: static void compile_recurse_fallbackpath(compiler_common *common, struct fallback_common *current)
5346: {
5347: DEFINE_COMPILER;
5348:
5349: set_jumps(current->topfallbacks, LABEL());
5350: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5351: free_stack(common, 1);
5352: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);
5353: }
5354:
5355: static void compile_assert_fallbackpath(compiler_common *common, struct fallback_common *current)
5356: {
5357: DEFINE_COMPILER;
5358: uschar *cc = current->cc;
5359: uschar bra = OP_BRA;
5360: struct sljit_jump *brajump = NULL;
5361:
5362: SLJIT_ASSERT(*cc != OP_BRAMINZERO);
5363: if (*cc == OP_BRAZERO)
5364: {
5365: bra = *cc;
5366: cc++;
5367: }
5368:
5369: if (bra == OP_BRAZERO)
5370: {
5371: SLJIT_ASSERT(current->topfallbacks == NULL);
5372: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5373: }
5374:
5375: if (CURRENT_AS(assert_fallback)->framesize < 0)
5376: {
5377: set_jumps(current->topfallbacks, LABEL());
5378:
5379: if (bra == OP_BRAZERO)
5380: {
5381: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5382: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_fallback)->hotpath);
5383: free_stack(common, 1);
5384: }
5385: return;
5386: }
5387:
5388: if (bra == OP_BRAZERO)
5389: {
5390: if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)
5391: {
5392: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5393: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_fallback)->hotpath);
5394: free_stack(common, 1);
5395: return;
5396: }
5397: free_stack(common, 1);
5398: brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
5399: }
5400:
5401: if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)
5402: {
5403: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr);
5404: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
5405: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_fallback)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(assert_fallback)->framesize * sizeof(sljit_w));
5406:
5407: set_jumps(current->topfallbacks, LABEL());
5408: }
5409: else
5410: set_jumps(current->topfallbacks, LABEL());
5411:
5412: if (bra == OP_BRAZERO)
5413: {
5414: /* We know there is enough place on the stack. */
5415: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
5416: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
5417: JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_fallback)->hotpath);
5418: JUMPHERE(brajump);
5419: }
5420: }
5421:
5422: static void compile_bracket_fallbackpath(compiler_common *common, struct fallback_common *current)
5423: {
5424: DEFINE_COMPILER;
5425: int opcode;
5426: int offset = 0;
5427: int localptr = CURRENT_AS(bracket_fallback)->localptr;
5428: int stacksize;
5429: int count;
5430: uschar *cc = current->cc;
5431: uschar *ccbegin;
5432: uschar *ccprev;
5433: jump_list *jumplist = NULL;
5434: jump_list *jumplistitem = NULL;
5435: uschar bra = OP_BRA;
5436: uschar ket;
5437: assert_fallback *assert;
5438: BOOL has_alternatives;
5439: struct sljit_jump *brazero = NULL;
5440: struct sljit_jump *once = NULL;
5441: struct sljit_jump *cond = NULL;
5442: struct sljit_label *rminlabel = NULL;
5443:
5444: if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
5445: {
5446: bra = *cc;
5447: cc++;
5448: }
5449:
5450: opcode = *cc;
5451: ccbegin = cc;
5452: ket = *(bracketend(ccbegin) - 1 - LINK_SIZE);
5453: cc += GET(cc, 1);
5454: has_alternatives = *cc == OP_ALT;
5455: if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
5456: has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_fallback)->u.condfailed != NULL;
5457: if (opcode == OP_CBRA || opcode == OP_SCBRA)
5458: offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;
5459: if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
5460: opcode = OP_SCOND;
5461: if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
5462: opcode = OP_ONCE;
5463:
5464: if (ket == OP_KETRMAX)
5465: {
5466: if (bra != OP_BRAZERO)
5467: free_stack(common, 1);
5468: else
5469: {
5470: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5471: free_stack(common, 1);
5472: brazero = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0);
5473: }
5474: }
5475: else if (ket == OP_KETRMIN)
5476: {
5477: if (bra != OP_BRAMINZERO)
5478: {
5479: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5480: if (opcode >= OP_SBRA || opcode == OP_ONCE)
5481: {
5482: /* Checking zero-length iteration. */
5483: if (opcode != OP_ONCE || CURRENT_AS(bracket_fallback)->u.framesize < 0)
5484: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, CURRENT_AS(bracket_fallback)->recursivehotpath);
5485: else
5486: {
5487: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
5488: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (CURRENT_AS(bracket_fallback)->u.framesize + 1) * sizeof(sljit_w), CURRENT_AS(bracket_fallback)->recursivehotpath);
5489: }
5490: if (opcode != OP_ONCE)
5491: free_stack(common, 1);
5492: }
5493: else
5494: JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->recursivehotpath);
5495: }
5496: rminlabel = LABEL();
5497: }
5498: else if (bra == OP_BRAZERO)
5499: {
5500: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5501: free_stack(common, 1);
5502: brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
5503: }
5504:
5505: if (SLJIT_UNLIKELY(opcode == OP_ONCE))
5506: {
5507: if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
5508: {
5509: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
5510: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
5511: }
5512: once = JUMP(SLJIT_JUMP);
5513: }
5514: else if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
5515: {
5516: if (has_alternatives)
5517: {
5518: /* Always exactly one alternative. */
5519: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5520: free_stack(common, 1);
5521:
5522: jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));
5523: if (SLJIT_UNLIKELY(!jumplistitem))
5524: return;
5525: jumplist = jumplistitem;
5526: jumplistitem->next = NULL;
5527: jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 1);
5528: }
5529: }
5530: else if (*cc == OP_ALT)
5531: {
5532: /* Build a jump list. Get the last successfully matched branch index. */
5533: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5534: free_stack(common, 1);
5535: count = 1;
5536: do
5537: {
5538: /* Append as the last item. */
5539: if (jumplist != NULL)
5540: {
5541: jumplistitem->next = sljit_alloc_memory(compiler, sizeof(jump_list));
5542: jumplistitem = jumplistitem->next;
5543: }
5544: else
5545: {
5546: jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));
5547: jumplist = jumplistitem;
5548: }
5549:
5550: if (SLJIT_UNLIKELY(!jumplistitem))
5551: return;
5552:
5553: jumplistitem->next = NULL;
5554: jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, count++);
5555: cc += GET(cc, 1);
5556: }
5557: while (*cc == OP_ALT);
5558:
5559: cc = ccbegin + GET(ccbegin, 1);
5560: }
5561:
5562: COMPILE_FALLBACKPATH(current->top);
5563: if (current->topfallbacks)
5564: set_jumps(current->topfallbacks, LABEL());
5565:
5566: if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
5567: {
5568: /* Conditional block always has at most one alternative. */
5569: if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)
5570: {
5571: SLJIT_ASSERT(has_alternatives);
5572: assert = CURRENT_AS(bracket_fallback)->u.assert;
5573: if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))
5574: {
5575: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr);
5576: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
5577: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_w));
5578: }
5579: cond = JUMP(SLJIT_JUMP);
5580: set_jumps(CURRENT_AS(bracket_fallback)->u.assert->condfailed, LABEL());
5581: }
5582: else if (CURRENT_AS(bracket_fallback)->u.condfailed != NULL)
5583: {
5584: SLJIT_ASSERT(has_alternatives);
5585: cond = JUMP(SLJIT_JUMP);
5586: set_jumps(CURRENT_AS(bracket_fallback)->u.condfailed, LABEL());
5587: }
5588: else
5589: SLJIT_ASSERT(!has_alternatives);
5590: }
5591:
5592: if (has_alternatives)
5593: {
5594: count = 1;
5595: do
5596: {
5597: current->top = NULL;
5598: current->topfallbacks = NULL;
5599: current->nextfallbacks = NULL;
5600: if (*cc == OP_ALT)
5601: {
5602: ccprev = cc + 1 + LINK_SIZE;
5603: cc += GET(cc, 1);
5604: if (opcode != OP_COND && opcode != OP_SCOND)
5605: {
5606: if (localptr != 0 && opcode != OP_ONCE)
5607: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
5608: else
5609: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5610: }
5611: compile_hotpath(common, ccprev, cc, current);
5612: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
5613: return;
5614: }
5615:
5616: /* Instructions after the current alternative is succesfully matched. */
5617: /* There is a similar code in compile_bracket_hotpath. */
5618: if (opcode == OP_ONCE)
5619: {
5620: if (CURRENT_AS(bracket_fallback)->u.framesize < 0)
5621: {
5622: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
5623: /* TMP2 which is set here used by OP_KETRMAX below. */
5624: if (ket == OP_KETRMAX)
5625: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);
5626: else if (ket == OP_KETRMIN)
5627: {
5628: /* Move the STR_PTR to the localptr. */
5629: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), 0);
5630: }
5631: }
5632: else
5633: {
5634: OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_IMM, (CURRENT_AS(bracket_fallback)->u.framesize + 2) * sizeof(sljit_w));
5635: if (ket == OP_KETRMAX)
5636: {
5637: /* TMP2 which is set here used by OP_KETRMAX below. */
5638: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5639: }
5640: }
5641: }
5642:
5643: stacksize = 0;
5644: if (opcode != OP_ONCE)
5645: stacksize++;
5646: if (ket != OP_KET || bra != OP_BRA)
5647: stacksize++;
5648:
5649: if (stacksize > 0) {
5650: if (opcode != OP_ONCE || CURRENT_AS(bracket_fallback)->u.framesize >= 0)
5651: allocate_stack(common, stacksize);
5652: else
5653: {
5654: /* We know we have place at least for one item on the top of the stack. */
5655: SLJIT_ASSERT(stacksize == 1);
5656: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_w));
5657: }
5658: }
5659:
5660: stacksize = 0;
5661: if (ket != OP_KET || bra != OP_BRA)
5662: {
5663: if (ket != OP_KET)
5664: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
5665: else
5666: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
5667: stacksize++;
5668: }
5669:
5670: if (opcode != OP_ONCE)
5671: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, count++);
5672:
5673: if (offset != 0)
5674: {
5675: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr);
5676: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);
5677: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 0), TMP1, 0);
5678: }
5679:
5680: JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->althotpath);
5681:
5682: if (opcode != OP_ONCE)
5683: {
5684: SLJIT_ASSERT(jumplist);
5685: JUMPHERE(jumplist->jump);
5686: jumplist = jumplist->next;
5687: }
5688:
5689: COMPILE_FALLBACKPATH(current->top);
5690: if (current->topfallbacks)
5691: set_jumps(current->topfallbacks, LABEL());
5692: SLJIT_ASSERT(!current->nextfallbacks);
5693: }
5694: while (*cc == OP_ALT);
5695: SLJIT_ASSERT(!jumplist);
5696:
5697: if (cond != NULL)
5698: {
5699: SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);
5700: assert = CURRENT_AS(bracket_fallback)->u.assert;
5701: if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)
5702:
5703: {
5704: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr);
5705: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
5706: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->localptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_w));
5707: }
5708: JUMPHERE(cond);
5709: }
5710:
5711: /* Free the STR_PTR. */
5712: if (localptr == 0)
5713: free_stack(common, 1);
5714: }
5715:
5716: if (offset != 0)
5717: {
5718: /* Using both tmp register is better for instruction scheduling. */
5719: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5720: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
5721: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
5722: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
5723: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), STACK(2));
5724: free_stack(common, 3);
5725: }
5726: else if (opcode == OP_SBRA || opcode == OP_SCOND)
5727: {
5728: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), STACK(0));
5729: free_stack(common, 1);
5730: }
5731: else if (opcode == OP_ONCE)
5732: {
5733: cc = ccbegin + GET(ccbegin, 1);
5734: if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
5735: {
5736: /* Reset head and drop saved frame. */
5737: stacksize = (ket == OP_KETRMAX || ket == OP_KETRMIN || *cc == OP_ALT) ? 2 : 1;
5738: free_stack(common, CURRENT_AS(bracket_fallback)->u.framesize + stacksize);
5739: }
5740: else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
5741: {
5742: /* The STR_PTR must be released. */
5743: free_stack(common, 1);
5744: }
5745:
5746: JUMPHERE(once);
5747: /* Restore previous localptr */
5748: if (CURRENT_AS(bracket_fallback)->u.framesize >= 0)
5749: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracket_fallback)->u.framesize * sizeof(sljit_w));
5750: else if (ket == OP_KETRMIN)
5751: {
5752: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
5753: /* See the comment below. */
5754: free_stack(common, 2);
5755: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), localptr, TMP1, 0);
5756: }
5757: }
5758:
5759: if (ket == OP_KETRMAX)
5760: {
5761: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5762: CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_fallback)->recursivehotpath);
5763: if (bra == OP_BRAZERO)
5764: {
5765: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
5766: JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->zerohotpath);
5767: JUMPHERE(brazero);
5768: }
5769: free_stack(common, 1);
5770: }
5771: else if (ket == OP_KETRMIN)
5772: {
5773: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5774:
5775: /* OP_ONCE removes everything in case of a fallback, so we don't
5776: need to explicitly release the STR_PTR. The extra release would
5777: affect badly the free_stack(2) above. */
5778: if (opcode != OP_ONCE)
5779: free_stack(common, 1);
5780: CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rminlabel);
5781: if (opcode == OP_ONCE)
5782: free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);
5783: else if (bra == OP_BRAMINZERO)
5784: free_stack(common, 1);
5785: }
5786: else if (bra == OP_BRAZERO)
5787: {
5788: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5789: JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_fallback)->zerohotpath);
5790: JUMPHERE(brazero);
5791: }
5792: }
5793:
5794: static void compile_bracketpos_fallbackpath(compiler_common *common, struct fallback_common *current)
5795: {
5796: DEFINE_COMPILER;
5797: int offset;
5798: struct sljit_jump *jump;
5799:
5800: if (CURRENT_AS(bracketpos_fallback)->framesize < 0)
5801: {
5802: if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)
5803: {
5804: offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;
5805: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5806: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
5807: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);
5808: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);
5809: }
5810: set_jumps(current->topfallbacks, LABEL());
5811: free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);
5812: return;
5813: }
5814:
5815: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_fallback)->localptr);
5816: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
5817:
5818: if (current->topfallbacks)
5819: {
5820: jump = JUMP(SLJIT_JUMP);
5821: set_jumps(current->topfallbacks, LABEL());
5822: /* Drop the stack frame. */
5823: free_stack(common, CURRENT_AS(bracketpos_fallback)->stacksize);
5824: JUMPHERE(jump);
5825: }
5826: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_fallback)->localptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracketpos_fallback)->framesize * sizeof(sljit_w));
5827: }
5828:
5829: static void compile_braminzero_fallbackpath(compiler_common *common, struct fallback_common *current)
5830: {
5831: assert_fallback fallback;
5832:
5833: current->top = NULL;
5834: current->topfallbacks = NULL;
5835: current->nextfallbacks = NULL;
5836: if (current->cc[1] > OP_ASSERTBACK_NOT)
5837: {
5838: /* Manual call of compile_bracket_hotpath and compile_bracket_fallbackpath. */
5839: compile_bracket_hotpath(common, current->cc, current);
5840: compile_bracket_fallbackpath(common, current->top);
5841: }
5842: else
5843: {
5844: memset(&fallback, 0, sizeof(fallback));
5845: fallback.common.cc = current->cc;
5846: fallback.hotpath = CURRENT_AS(braminzero_fallback)->hotpath;
5847: /* Manual call of compile_assert_hotpath. */
5848: compile_assert_hotpath(common, current->cc, &fallback, FALSE);
5849: }
5850: SLJIT_ASSERT(!current->nextfallbacks && !current->topfallbacks);
5851: }
5852:
5853: static void compile_fallbackpath(compiler_common *common, struct fallback_common *current)
5854: {
5855: DEFINE_COMPILER;
5856:
5857: while (current)
5858: {
5859: if (current->nextfallbacks != NULL)
5860: set_jumps(current->nextfallbacks, LABEL());
5861: switch(*current->cc)
5862: {
5863: case OP_SET_SOM:
5864: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
5865: free_stack(common, 1);
5866: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP1, 0);
5867: break;
5868:
5869: case OP_STAR:
5870: case OP_MINSTAR:
5871: case OP_PLUS:
5872: case OP_MINPLUS:
5873: case OP_QUERY:
5874: case OP_MINQUERY:
5875: case OP_UPTO:
5876: case OP_MINUPTO:
5877: case OP_EXACT:
5878: case OP_POSSTAR:
5879: case OP_POSPLUS:
5880: case OP_POSQUERY:
5881: case OP_POSUPTO:
5882: case OP_STARI:
5883: case OP_MINSTARI:
5884: case OP_PLUSI:
5885: case OP_MINPLUSI:
5886: case OP_QUERYI:
5887: case OP_MINQUERYI:
5888: case OP_UPTOI:
5889: case OP_MINUPTOI:
5890: case OP_EXACTI:
5891: case OP_POSSTARI:
5892: case OP_POSPLUSI:
5893: case OP_POSQUERYI:
5894: case OP_POSUPTOI:
5895: case OP_NOTSTAR:
5896: case OP_NOTMINSTAR:
5897: case OP_NOTPLUS:
5898: case OP_NOTMINPLUS:
5899: case OP_NOTQUERY:
5900: case OP_NOTMINQUERY:
5901: case OP_NOTUPTO:
5902: case OP_NOTMINUPTO:
5903: case OP_NOTEXACT:
5904: case OP_NOTPOSSTAR:
5905: case OP_NOTPOSPLUS:
5906: case OP_NOTPOSQUERY:
5907: case OP_NOTPOSUPTO:
5908: case OP_NOTSTARI:
5909: case OP_NOTMINSTARI:
5910: case OP_NOTPLUSI:
5911: case OP_NOTMINPLUSI:
5912: case OP_NOTQUERYI:
5913: case OP_NOTMINQUERYI:
5914: case OP_NOTUPTOI:
5915: case OP_NOTMINUPTOI:
5916: case OP_NOTEXACTI:
5917: case OP_NOTPOSSTARI:
5918: case OP_NOTPOSPLUSI:
5919: case OP_NOTPOSQUERYI:
5920: case OP_NOTPOSUPTOI:
5921: case OP_TYPESTAR:
5922: case OP_TYPEMINSTAR:
5923: case OP_TYPEPLUS:
5924: case OP_TYPEMINPLUS:
5925: case OP_TYPEQUERY:
5926: case OP_TYPEMINQUERY:
5927: case OP_TYPEUPTO:
5928: case OP_TYPEMINUPTO:
5929: case OP_TYPEEXACT:
5930: case OP_TYPEPOSSTAR:
5931: case OP_TYPEPOSPLUS:
5932: case OP_TYPEPOSQUERY:
5933: case OP_TYPEPOSUPTO:
5934: case OP_CLASS:
5935: case OP_NCLASS:
5936: case OP_XCLASS:
5937: compile_iterator_fallbackpath(common, current);
5938: break;
5939:
5940: case OP_REF:
5941: case OP_REFI:
5942: compile_ref_iterator_fallbackpath(common, current);
5943: break;
5944:
5945: case OP_RECURSE:
5946: compile_recurse_fallbackpath(common, current);
5947: break;
5948:
5949: case OP_ASSERT:
5950: case OP_ASSERT_NOT:
5951: case OP_ASSERTBACK:
5952: case OP_ASSERTBACK_NOT:
5953: compile_assert_fallbackpath(common, current);
5954: break;
5955:
5956: case OP_ONCE:
5957: case OP_ONCE_NC:
5958: case OP_BRA:
5959: case OP_CBRA:
5960: case OP_COND:
5961: case OP_SBRA:
5962: case OP_SCBRA:
5963: case OP_SCOND:
5964: compile_bracket_fallbackpath(common, current);
5965: break;
5966:
5967: case OP_BRAZERO:
5968: if (current->cc[1] > OP_ASSERTBACK_NOT)
5969: compile_bracket_fallbackpath(common, current);
5970: else
5971: compile_assert_fallbackpath(common, current);
5972: break;
5973:
5974: case OP_BRAPOS:
5975: case OP_CBRAPOS:
5976: case OP_SBRAPOS:
5977: case OP_SCBRAPOS:
5978: case OP_BRAPOSZERO:
5979: compile_bracketpos_fallbackpath(common, current);
5980: break;
5981:
5982: case OP_BRAMINZERO:
5983: compile_braminzero_fallbackpath(common, current);
5984: break;
5985:
5986: case OP_FAIL:
5987: case OP_ACCEPT:
5988: case OP_ASSERT_ACCEPT:
5989: set_jumps(current->topfallbacks, LABEL());
5990: break;
5991:
5992: default:
5993: SLJIT_ASSERT_STOP();
5994: break;
5995: }
5996: current = current->prev;
5997: }
5998: }
5999:
6000: static SLJIT_INLINE void compile_recurse(compiler_common *common)
6001: {
6002: DEFINE_COMPILER;
6003: uschar *cc = common->start + common->currententry->start;
6004: uschar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : 2);
6005: uschar *ccend = bracketend(cc);
6006: int localsize = get_localsize(common, ccbegin, ccend);
6007: int framesize = get_framesize(common, cc, TRUE);
6008: int alternativesize;
6009: BOOL needsframe;
6010: fallback_common altfallback;
6011: struct sljit_jump *jump;
6012:
6013: SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);
6014: needsframe = framesize >= 0;
6015: if (!needsframe)
6016: framesize = 0;
6017: alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;
6018:
6019: SLJIT_ASSERT(common->currententry->entry == NULL);
6020: common->currententry->entry = LABEL();
6021: set_jumps(common->currententry->calls, common->currententry->entry);
6022:
6023: sljit_emit_fast_enter(compiler, TMP2, 0, 1, 5, 5, common->localsize);
6024: allocate_stack(common, localsize + framesize + alternativesize);
6025: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(localsize + framesize + alternativesize - 1), TMP2, 0);
6026: copy_locals(common, ccbegin, ccend, TRUE, localsize + framesize + alternativesize, framesize + alternativesize);
6027: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), RECURSIVE_HEAD, STACK_TOP, 0);
6028: if (needsframe)
6029: init_frame(common, cc, framesize + alternativesize - 1, alternativesize, FALSE);
6030:
6031: if (alternativesize > 0)
6032: OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
6033:
6034: memset(&altfallback, 0, sizeof(fallback_common));
6035: common->acceptlabel = NULL;
6036: common->accept = NULL;
6037: altfallback.cc = ccbegin;
6038: cc += GET(cc, 1);
6039: while (1)
6040: {
6041: altfallback.top = NULL;
6042: altfallback.topfallbacks = NULL;
6043:
6044: if (altfallback.cc != ccbegin)
6045: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
6046:
6047: compile_hotpath(common, altfallback.cc, cc, &altfallback);
6048: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
6049: return;
6050:
6051: add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
6052:
6053: compile_fallbackpath(common, altfallback.top);
6054: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
6055: return;
6056: set_jumps(altfallback.topfallbacks, LABEL());
6057:
6058: if (*cc != OP_ALT)
6059: break;
6060:
6061: altfallback.cc = cc + 1 + LINK_SIZE;
6062: cc += GET(cc, 1);
6063: }
6064: /* None of them matched. */
6065: OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
6066: jump = JUMP(SLJIT_JUMP);
6067:
6068: set_jumps(common->accept, LABEL());
6069: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), RECURSIVE_HEAD);
6070: if (needsframe)
6071: {
6072: OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
6073: OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_w));
6074: add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
6075: OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_w));
6076: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP3, 0);
6077: }
6078: OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);
6079:
6080: JUMPHERE(jump);
6081: copy_locals(common, ccbegin, ccend, FALSE, localsize + framesize + alternativesize, framesize + alternativesize);
6082: free_stack(common, localsize + framesize + alternativesize);
6083: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_w));
6084: OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
6085: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), RECURSIVE_HEAD, TMP2, 0);
6086: sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), 0);
6087: }
6088:
6089: #undef COMPILE_FALLBACKPATH
6090: #undef CURRENT_AS
6091:
6092: void
6093: _pcre_jit_compile(const real_pcre *re, pcre_extra *extra)
6094: {
6095: struct sljit_compiler *compiler;
6096: fallback_common rootfallback;
6097: compiler_common common_data;
6098: compiler_common *common = &common_data;
6099: const uschar *tables = re->tables;
6100: pcre_study_data *study;
6101: uschar *ccend;
6102: executable_function *function;
6103: void *executable_func;
6104: sljit_uw executable_size;
6105: struct sljit_label *leave;
6106: struct sljit_label *mainloop = NULL;
6107: struct sljit_label *empty_match_found;
6108: struct sljit_label *empty_match_fallback;
6109: struct sljit_jump *alloc_error;
6110: struct sljit_jump *reqbyte_notfound = NULL;
6111: struct sljit_jump *empty_match;
6112:
6113: SLJIT_ASSERT((extra->flags & PCRE_EXTRA_STUDY_DATA) != 0);
6114: study = extra->study_data;
6115:
6116: if (!tables)
6117: tables = _pcre_default_tables;
6118:
6119: memset(&rootfallback, 0, sizeof(fallback_common));
6120: rootfallback.cc = (uschar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
6121:
6122: common->compiler = NULL;
6123: common->start = rootfallback.cc;
6124: common->cbraptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_w);
6125: common->fcc = tables + fcc_offset;
6126: common->lcc = (sljit_w)(tables + lcc_offset);
6127: common->nltype = NLTYPE_FIXED;
6128: switch(re->options & PCRE_NEWLINE_BITS)
6129: {
6130: case 0:
6131: /* Compile-time default */
6132: switch (NEWLINE)
6133: {
6134: case -1: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;
6135: case -2: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;
6136: default: common->newline = NEWLINE; break;
6137: }
6138: break;
6139: case PCRE_NEWLINE_CR: common->newline = CHAR_CR; break;
6140: case PCRE_NEWLINE_LF: common->newline = CHAR_NL; break;
6141: case PCRE_NEWLINE_CR+
6142: PCRE_NEWLINE_LF: common->newline = (CHAR_CR << 8) | CHAR_NL; break;
6143: case PCRE_NEWLINE_ANY: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;
6144: case PCRE_NEWLINE_ANYCRLF: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;
6145: default: return;
6146: }
6147: if ((re->options & PCRE_BSR_ANYCRLF) != 0)
6148: common->bsr_nltype = NLTYPE_ANYCRLF;
6149: else if ((re->options & PCRE_BSR_UNICODE) != 0)
6150: common->bsr_nltype = NLTYPE_ANY;
6151: else
6152: {
6153: #ifdef BSR_ANYCRLF
6154: common->bsr_nltype = NLTYPE_ANYCRLF;
6155: #else
6156: common->bsr_nltype = NLTYPE_ANY;
6157: #endif
6158: }
6159: common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
6160: common->ctypes = (sljit_w)(tables + ctypes_offset);
6161: common->name_table = (sljit_w)re + re->name_table_offset;
6162: common->name_count = re->name_count;
6163: common->name_entry_size = re->name_entry_size;
6164: common->acceptlabel = NULL;
6165: common->stubs = NULL;
6166: common->entries = NULL;
6167: common->currententry = NULL;
6168: common->accept = NULL;
6169: common->calllimit = NULL;
6170: common->stackalloc = NULL;
6171: common->revertframes = NULL;
6172: common->wordboundary = NULL;
6173: common->anynewline = NULL;
6174: common->hspace = NULL;
6175: common->vspace = NULL;
6176: common->casefulcmp = NULL;
6177: common->caselesscmp = NULL;
6178: common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
6179: #ifdef SUPPORT_UTF8
6180: common->utf8 = (re->options & PCRE_UTF8) != 0;
6181: #ifdef SUPPORT_UCP
6182: common->useucp = (re->options & PCRE_UCP) != 0;
6183: #endif
6184: common->utf8readchar = NULL;
6185: common->utf8readtype8 = NULL;
6186: #endif
6187: #ifdef SUPPORT_UCP
6188: common->getucd = NULL;
6189: #endif
6190: ccend = bracketend(rootfallback.cc);
6191: SLJIT_ASSERT(*rootfallback.cc == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);
6192: common->localsize = get_localspace(common, rootfallback.cc, ccend);
6193: if (common->localsize < 0)
6194: return;
6195: common->localsize += common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w);
6196: if (common->localsize > SLJIT_MAX_LOCAL_SIZE)
6197: return;
6198: common->localptrs = (int*)SLJIT_MALLOC((ccend - rootfallback.cc) * sizeof(int));
6199: if (!common->localptrs)
6200: return;
6201: memset(common->localptrs, 0, (ccend - rootfallback.cc) * sizeof(int));
6202: set_localptrs(common, common->cbraptr + (re->top_bracket + 1) * sizeof(sljit_w), ccend);
6203:
6204: compiler = sljit_create_compiler();
6205: if (!compiler)
6206: {
6207: SLJIT_FREE(common->localptrs);
6208: return;
6209: }
6210: common->compiler = compiler;
6211:
6212: /* Main pcre_jit_exec entry. */
6213: sljit_emit_enter(compiler, 1, 5, 5, common->localsize);
6214:
6215: /* Register init. */
6216: reset_ovector(common, (re->top_bracket + 1) * 2);
6217: if ((re->flags & PCRE_REQCHSET) != 0)
6218: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), REQ_BYTE_PTR, SLJIT_TEMPORARY_REG1, 0);
6219:
6220: OP1(SLJIT_MOV, ARGUMENTS, 0, SLJIT_GENERAL_REG1, 0);
6221: OP1(SLJIT_MOV, TMP1, 0, SLJIT_GENERAL_REG1, 0);
6222: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
6223: OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, end));
6224: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
6225: OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, calllimit));
6226: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, base));
6227: OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, limit));
6228: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT, TMP1, 0);
6229:
6230: /* Main part of the matching */
6231: if ((re->options & PCRE_ANCHORED) == 0)
6232: {
6233: mainloop = mainloop_entry(common, (re->flags & PCRE_HASCRORLF) != 0, (re->options & PCRE_FIRSTLINE) != 0);
6234: /* Forward search if possible. */
6235: if ((re->flags & PCRE_FIRSTSET) != 0)
6236: fast_forward_first_byte(common, re->first_byte, (re->options & PCRE_FIRSTLINE) != 0);
6237: else if ((re->flags & PCRE_STARTLINE) != 0)
6238: fast_forward_newline(common, (re->options & PCRE_FIRSTLINE) != 0);
6239: else if ((re->flags & PCRE_STARTLINE) == 0 && study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)
6240: fast_forward_start_bits(common, (sljit_uw)study->start_bits, (re->options & PCRE_FIRSTLINE) != 0);
6241: }
6242: if ((re->flags & PCRE_REQCHSET) != 0)
6243: reqbyte_notfound = search_requested_char(common, re->req_byte, (re->flags & PCRE_FIRSTSET) != 0);
6244:
6245: /* Store the current STR_PTR in OVECTOR(0). */
6246: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);
6247: /* Copy the limit of allowed recursions. */
6248: OP1(SLJIT_MOV, CALL_COUNT, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CALL_LIMIT);
6249:
6250: compile_hotpath(common, rootfallback.cc, ccend, &rootfallback);
6251: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
6252: {
6253: sljit_free_compiler(compiler);
6254: SLJIT_FREE(common->localptrs);
6255: return;
6256: }
6257:
6258: empty_match = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
6259: empty_match_found = LABEL();
6260:
6261: common->acceptlabel = LABEL();
6262: if (common->accept != NULL)
6263: set_jumps(common->accept, common->acceptlabel);
6264:
6265: /* This means we have a match. Update the ovector. */
6266: copy_ovector(common, re->top_bracket + 1);
6267: leave = LABEL();
6268: sljit_emit_return(compiler, SLJIT_UNUSED, 0);
6269:
6270: empty_match_fallback = LABEL();
6271: compile_fallbackpath(common, rootfallback.top);
6272: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
6273: {
6274: sljit_free_compiler(compiler);
6275: SLJIT_FREE(common->localptrs);
6276: return;
6277: }
6278:
6279: SLJIT_ASSERT(rootfallback.prev == NULL);
6280:
6281: /* Check we have remaining characters. */
6282: OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));
6283:
6284: if ((re->options & PCRE_ANCHORED) == 0)
6285: {
6286: if ((re->options & PCRE_FIRSTLINE) == 0)
6287: {
6288: if (study != NULL && study->minlength > 1)
6289: {
6290: OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, study->minlength);
6291: CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_END, 0, mainloop);
6292: }
6293: else
6294: CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);
6295: }
6296: else
6297: {
6298: if (study != NULL && study->minlength > 1)
6299: {
6300: OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, study->minlength);
6301: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, STR_END, 0);
6302: COND_VALUE(SLJIT_MOV, TMP2, 0, SLJIT_C_GREATER);
6303: OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END);
6304: COND_VALUE(SLJIT_OR | SLJIT_SET_E, TMP2, 0, SLJIT_C_GREATER_EQUAL);
6305: JUMPTO(SLJIT_C_ZERO, mainloop);
6306: }
6307: else
6308: CMPTO(SLJIT_C_LESS, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), FIRSTLINE_END, mainloop);
6309: }
6310: }
6311:
6312: if (reqbyte_notfound != NULL)
6313: JUMPHERE(reqbyte_notfound);
6314: /* Copy OVECTOR(1) to OVECTOR(0) */
6315: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));
6316: OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
6317: JUMPTO(SLJIT_JUMP, leave);
6318:
6319: flush_stubs(common);
6320:
6321: JUMPHERE(empty_match);
6322: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
6323: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
6324: CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_fallback);
6325: OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
6326: CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_found);
6327: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
6328: CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, empty_match_found);
6329: JUMPTO(SLJIT_JUMP, empty_match_fallback);
6330:
6331: common->currententry = common->entries;
6332: while (common->currententry != NULL)
6333: {
6334: /* Might add new entries. */
6335: compile_recurse(common);
6336: if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
6337: {
6338: sljit_free_compiler(compiler);
6339: SLJIT_FREE(common->localptrs);
6340: return;
6341: }
6342: flush_stubs(common);
6343: common->currententry = common->currententry->next;
6344: }
6345:
6346: /* Allocating stack, returns with PCRE_ERROR_JIT_STACKLIMIT if fails. */
6347: /* This is a (really) rare case. */
6348: set_jumps(common->stackalloc, LABEL());
6349: /* RETURN_ADDR is not a saved register. */
6350: sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, 1, 5, 5, common->localsize);
6351: OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);
6352: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
6353: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
6354: OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top), STACK_TOP, 0);
6355: OP2(SLJIT_ADD, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit), SLJIT_IMM, STACK_GROWTH_RATE);
6356:
6357: sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize));
6358: alloc_error = CMP(SLJIT_C_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
6359: OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
6360: OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
6361: OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top));
6362: OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit));
6363: OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);
6364: sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);
6365:
6366: /* Allocation failed. */
6367: JUMPHERE(alloc_error);
6368: /* We break the return address cache here, but this is a really rare case. */
6369: OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_JIT_STACKLIMIT);
6370: JUMPTO(SLJIT_JUMP, leave);
6371:
6372: /* Call limit reached. */
6373: set_jumps(common->calllimit, LABEL());
6374: OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_MATCHLIMIT);
6375: JUMPTO(SLJIT_JUMP, leave);
6376:
6377: if (common->revertframes != NULL)
6378: {
6379: set_jumps(common->revertframes, LABEL());
6380: do_revertframes(common);
6381: }
6382: if (common->wordboundary != NULL)
6383: {
6384: set_jumps(common->wordboundary, LABEL());
6385: check_wordboundary(common);
6386: }
6387: if (common->anynewline != NULL)
6388: {
6389: set_jumps(common->anynewline, LABEL());
6390: check_anynewline(common);
6391: }
6392: if (common->hspace != NULL)
6393: {
6394: set_jumps(common->hspace, LABEL());
6395: check_hspace(common);
6396: }
6397: if (common->vspace != NULL)
6398: {
6399: set_jumps(common->vspace, LABEL());
6400: check_vspace(common);
6401: }
6402: if (common->casefulcmp != NULL)
6403: {
6404: set_jumps(common->casefulcmp, LABEL());
6405: do_casefulcmp(common);
6406: }
6407: if (common->caselesscmp != NULL)
6408: {
6409: set_jumps(common->caselesscmp, LABEL());
6410: do_caselesscmp(common);
6411: }
6412: #ifdef SUPPORT_UTF8
6413: if (common->utf8readchar != NULL)
6414: {
6415: set_jumps(common->utf8readchar, LABEL());
6416: do_utf8readchar(common);
6417: }
6418: if (common->utf8readtype8 != NULL)
6419: {
6420: set_jumps(common->utf8readtype8, LABEL());
6421: do_utf8readtype8(common);
6422: }
6423: #endif
6424: #ifdef SUPPORT_UCP
6425: if (common->getucd != NULL)
6426: {
6427: set_jumps(common->getucd, LABEL());
6428: do_getucd(common);
6429: }
6430: #endif
6431:
6432: SLJIT_FREE(common->localptrs);
6433: executable_func = sljit_generate_code(compiler);
6434: executable_size = sljit_get_generated_code_size(compiler);
6435: sljit_free_compiler(compiler);
6436: if (executable_func == NULL)
6437: return;
6438:
6439: function = SLJIT_MALLOC(sizeof(executable_function));
6440: if (function == NULL)
6441: {
6442: /* This case is highly unlikely since we just recently
6443: freed a lot of memory. Although not impossible. */
6444: sljit_free_code(executable_func);
6445: return;
6446: }
6447:
6448: function->executable_func = executable_func;
6449: function->executable_size = executable_size;
6450: function->callback = NULL;
6451: function->userdata = NULL;
6452: extra->executable_jit = function;
6453: extra->flags |= PCRE_EXTRA_EXECUTABLE_JIT;
6454: }
6455:
6456: static int jit_machine_stack_exec(jit_arguments *arguments, executable_function *function)
6457: {
6458: union {
6459: void* executable_func;
6460: jit_function call_executable_func;
6461: } convert_executable_func;
6462: uschar local_area[LOCAL_SPACE_SIZE];
6463: struct sljit_stack local_stack;
6464:
6465: local_stack.top = (sljit_w)&local_area;
6466: local_stack.base = local_stack.top;
6467: local_stack.limit = local_stack.base + LOCAL_SPACE_SIZE;
6468: local_stack.max_limit = local_stack.limit;
6469: arguments->stack = &local_stack;
6470: convert_executable_func.executable_func = function->executable_func;
6471: return convert_executable_func.call_executable_func(arguments);
6472: }
6473:
6474: int
6475: _pcre_jit_exec(const real_pcre *re, void *executable_func,
6476: PCRE_SPTR subject, int length, int start_offset, int options,
6477: int match_limit, int *offsets, int offsetcount)
6478: {
6479: executable_function *function = (executable_function*)executable_func;
6480: union {
6481: void* executable_func;
6482: jit_function call_executable_func;
6483: } convert_executable_func;
6484: jit_arguments arguments;
6485: int maxoffsetcount;
6486: int retval;
6487:
6488: /* Sanity checks should be handled by pcre_exec. */
6489: arguments.stack = NULL;
6490: arguments.str = subject + start_offset;
6491: arguments.begin = subject;
6492: arguments.end = subject + length;
6493: arguments.calllimit = match_limit; /* JIT decreases this value less times. */
6494: arguments.notbol = (options & PCRE_NOTBOL) != 0;
6495: arguments.noteol = (options & PCRE_NOTEOL) != 0;
6496: arguments.notempty = (options & PCRE_NOTEMPTY) != 0;
6497: arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
6498: arguments.offsets = offsets;
6499:
6500: /* pcre_exec() rounds offsetcount to a multiple of 3, and then uses only 2/3 of
6501: the output vector for storing captured strings, with the remainder used as
6502: workspace. We don't need the workspace here. For compatibility, we limit the
6503: number of captured strings in the same way as pcre_exec(), so that the user
6504: gets the same result with and without JIT. */
6505:
6506: offsetcount = ((offsetcount - (offsetcount % 3)) * 2)/3;
6507: maxoffsetcount = (re->top_bracket + 1) * 2;
6508: if (offsetcount > maxoffsetcount)
6509: offsetcount = maxoffsetcount;
6510: arguments.offsetcount = offsetcount;
6511:
6512: if (function->callback)
6513: arguments.stack = (struct sljit_stack*)function->callback(function->userdata);
6514: else
6515: arguments.stack = (struct sljit_stack*)function->userdata;
6516:
6517: if (arguments.stack == NULL)
6518: retval = jit_machine_stack_exec(&arguments, function);
6519: else
6520: {
6521: convert_executable_func.executable_func = function->executable_func;
6522: retval = convert_executable_func.call_executable_func(&arguments);
6523: }
6524:
6525: if (retval * 2 > offsetcount)
6526: retval = 0;
6527: return retval;
6528: }
6529:
6530: void
6531: _pcre_jit_free(void *executable_func)
6532: {
6533: executable_function *function = (executable_function*)executable_func;
6534: sljit_free_code(function->executable_func);
6535: SLJIT_FREE(function);
6536: }
6537:
6538: int
6539: _pcre_jit_get_size(void *executable_func)
6540: {
6541: return ((executable_function*)executable_func)->executable_size;
6542: }
6543:
6544: PCRE_EXP_DECL pcre_jit_stack *
6545: pcre_jit_stack_alloc(int startsize, int maxsize)
6546: {
6547: if (startsize < 1 || maxsize < 1)
6548: return NULL;
6549: if (startsize > maxsize)
6550: startsize = maxsize;
6551: startsize = (startsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);
6552: maxsize = (maxsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);
6553: return (pcre_jit_stack*)sljit_allocate_stack(startsize, maxsize);
6554: }
6555:
6556: PCRE_EXP_DECL void
6557: pcre_jit_stack_free(pcre_jit_stack *stack)
6558: {
6559: sljit_free_stack((struct sljit_stack*)stack);
6560: }
6561:
6562: PCRE_EXP_DECL void
6563: pcre_assign_jit_stack(pcre_extra *extra, pcre_jit_callback callback, void *userdata)
6564: {
6565: executable_function *function;
6566: if (extra != NULL &&
6567: (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
6568: extra->executable_jit != NULL)
6569: {
6570: function = (executable_function*)extra->executable_jit;
6571: function->callback = callback;
6572: function->userdata = userdata;
6573: }
6574: }
6575:
6576: #else /* SUPPORT_JIT */
6577:
6578: /* These are dummy functions to avoid linking errors when JIT support is not
6579: being compiled. */
6580:
6581: PCRE_EXP_DECL pcre_jit_stack *
6582: pcre_jit_stack_alloc(int startsize, int maxsize)
6583: {
6584: (void)startsize;
6585: (void)maxsize;
6586: return NULL;
6587: }
6588:
6589: PCRE_EXP_DECL void
6590: pcre_jit_stack_free(pcre_jit_stack *stack)
6591: {
6592: (void)stack;
6593: }
6594:
6595: PCRE_EXP_DECL void
6596: pcre_assign_jit_stack(pcre_extra *extra, pcre_jit_callback callback, void *userdata)
6597: {
6598: (void)extra;
6599: (void)callback;
6600: (void)userdata;
6601: }
6602:
6603: #endif
6604:
6605: /* End of pcre_jit_compile.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_jit_compile.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre