Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
71 // Call the construct code with 2 arguments.
136 // More makes code generation slower, less makes V8 benchmark score lower.
144 // than the code used for atom matches.
375 #else // V8_INTERPRETED_REGEXP (RegExp native code)
382 // Reinstate the code in the original place.
415 // saved code index.
418 // uncompiled regexp, a previous compilation error, or code that has
428 // the saved code index (we store the error message, not the actual
472 data->set(JSRegExp::code_index(is_ascii), result.code);
508 Code* RegExpImpl::IrregexpNativeCode(FixedArray* re, bool is_ascii) {
509 return Code::cast(re->get(JSRegExp::code_index(is_ascii)));
517 // Initialize compiled code entries to null.
535 // Byte-code regexp needs space allocated for all its registers.
568 Handle<Code> code(IrregexpNativeCode(*irregexp, is_ascii), isolate);
569 // The stack is used to allocate registers for the compiled regexp code.
574 NativeRegExpMacroAssembler::Match(code,
769 // bytecodes or native code.
777 // 3) From the nodes we generate either byte codes or native code
779 // the search). The code generation step is described in more
782 // Code generation.
803 // The code generated (whether as byte codes or native code) maintains
815 // which will be presented first. The actual code generated is a more
821 // push backtrack code location
822 // <generate code to test for choice>
823 // backtrack code location:
826 // <generate code to test for last choice>
830 // <generate code to perform action>
831 // push backtrack code location
832 // <generate code to test for following nodes>
833 // backtrack code location:
840 // <generate code to test for following nodes>
850 // the node has already been code generated then the Emit() call will
851 // generate a jump to the previously generated code instead. In order to
854 // destination of the jump is resolved later when the code is generated.
856 // Actual regular expression code generation.
858 // Code generation is actually more complicated than the above. In order
859 // to improve the efficiency of the generated code some optimizations are
880 // are needed and to generate code for a node more than once, allowing
881 // specialized an efficient versions of the code to be created. This is
886 // Instead of emitting code, nodes that manipulate the state can record their
888 // current position offset, an optional backtrack code location on the top of
891 // will emit code to bring the actual state into line with the virtual state.
896 // known backtrack code location than it is to pop an unknown backtrack
899 // The virtual state found in the Trace affects code generation. For example
901 // position and the virtual current position, and matching code needs to use
903 // string. Therefore code generated for a non-trivial trace is specialized
904 // to that trace. The code generator therefore has the ability to generate
905 // code for each node several times. In order to limit the size of the
906 // generated code there is an arbitrary limit on how many specialized sets of
907 // code may be generated for a given node. If the limit is reached, the
908 // trace is flushed and a generic version of the code for a node is emitted.
909 // This is subsequently used for that node. The code emitted for non-generic
911 // the event that code generation is requested for an identical trace.
1095 // Attempts to compile the regexp using an Irregexp code generator. Returns
1150 Handle<HeapObject> code = macro_assembler_->GetCode(pattern);
1151 heap->IncreaseTotalRegexpCodeGenerated(code->Size());
1155 Handle<Code>::cast(code)->Disassemble(*pattern->ToCString());
1161 return RegExpEngine::CompilationResult(*code, next_register_);
1372 // nodes. It normalizes the state of the code generator to ensure we can
1373 // generate generic code.
1390 // Generate deferred actions here along with code to undo them again.
1442 // so this code can be used as the generic version.
1586 // Emit code.
1715 // involved in order to simplify code generation.
1946 // The first test ensures that we get to the code that handles the ASCII
2213 // A new list with ascending entries. Each entry is a code unit
2214 // where there is a boundary between code units that are part of
2215 // the class and code units that are not. Normally we insert an
2259 // If we are generating a greedy loop then don't stop and don't reuse code.
2293 // If we get here code has been generated for this node too many times or
2294 // recursion is too deep. Time to switch to a generic version. The code for
3030 // Emit the code to check for a ^ in multiline mode (1-character lookbehind
3066 // Emit the code to handle \b and \B (word-boundary or non-word-boundary).
3216 // We call this repeatedly to generate code for each pass over the text node.
3240 // order to get to the code we are now generating. The quick check can involve
3339 // This generates the code to match a text node. A text node can contain
3343 // emitting code for some character positions every time. See the comment on
3484 // Later we will generate code for all these text nodes using recursion
3561 // records the way the alternative is being code generated.
3851 /* Code generation for choice nodes.
3863 * next GoTo if we decide to reuse some already generated code. Some
3902 * than fail. Therefore we want the loop code to look like this (U is the
3903 * unwind code that steps back in the greedy loop). The following alternatives
4094 // No quick check was generated. Put the full code here.
4177 // code through a quick check which already did the checked load.
4926 // combined if it turns out they hinder good code generation.
5605 // because the following code only handles ranges that start on
