Omit JIT compiler from precompiled runtime on ARM, ARM64 and IA32.

runtime/vm/regexp.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp.h"
 
 #include "vm/dart_entry.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp_assembler_bytecode.h"
 #include "vm/regexp_assembler_ir.h"
 #include "vm/regexp_ast.h"
 #include "vm/unibrow-inl.h"
 #include "vm/unicode.h"
 #include "vm/symbols.h"
 #include "vm/thread.h"
 
 #define Z (zone())
 
 namespace dart {
 
-DECLARE_FLAG(bool, trace_irregexp);
-
 // Default to generating optimized regexp code.
 static const bool kRegexpOptimization = true;
 
 // More makes code generation slower, less makes V8 benchmark score lower.
 static const intptr_t kMaxLookaheadForBoyerMoore = 8;
 
 ContainedInLattice AddRange(ContainedInLattice containment,
                             const intptr_t* ranges,
                             intptr_t ranges_length,
                             Interval new_range) {
@@ skipping 258 matching lines @@
   intptr_t total_samples_;
 };
 
 
 class RegExpCompiler : public ValueObject {
  public:
   RegExpCompiler(intptr_t capture_count, bool ignore_case, bool is_one_byte);
 
   intptr_t AllocateRegister() { return next_register_++; }
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
   RegExpEngine::CompilationResult Assemble(IRRegExpMacroAssembler* assembler,
                                            RegExpNode* start,
                                            intptr_t capture_count,
                                            const String& pattern);
+#endif
 
   RegExpEngine::CompilationResult Assemble(
       BytecodeRegExpMacroAssembler* assembler,
       RegExpNode* start,
       intptr_t capture_count,
       const String& pattern);
 
   inline void AddWork(RegExpNode* node) { work_list_->Add(node); }
 
   static const intptr_t kImplementationOffset = 0;
@@ skipping 65 matching lines @@
       recursion_depth_(0),
       ignore_case_(ignore_case),
       is_one_byte_(is_one_byte),
       reg_exp_too_big_(false),
       current_expansion_factor_(1),
       zone_(Thread::Current()->zone()) {
   accept_ = new (Z) EndNode(EndNode::ACCEPT, Z);
 }
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 RegExpEngine::CompilationResult RegExpCompiler::Assemble(
     IRRegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     intptr_t capture_count,
     const String& pattern) {
   macro_assembler->set_slow_safe(false /* use_slow_safe_regexp_compiler */);
   macro_assembler_ = macro_assembler;
 
   ZoneGrowableArray<RegExpNode*> work_list(0);
   work_list_ = &work_list;
   BlockLabel fail;
   macro_assembler_->PushBacktrack(&fail);
   Trace new_trace;
   start->Emit(this, &new_trace);
   macro_assembler_->BindBlock(&fail);
   macro_assembler_->Fail();
   while (!work_list.is_empty()) {
     work_list.RemoveLast()->Emit(this, &new_trace);
   }
   if (reg_exp_too_big_) return IrregexpRegExpTooBig();
 
   macro_assembler->GenerateBacktrackBlock();
   macro_assembler->FinalizeRegistersArray();
 
   return RegExpEngine::CompilationResult(
       macro_assembler->backtrack_goto(), macro_assembler->graph_entry(),
       macro_assembler->num_blocks(), macro_assembler->num_stack_locals(),
       next_register_);
 }
+#endif
 
 
 RegExpEngine::CompilationResult RegExpCompiler::Assemble(
     BytecodeRegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     intptr_t capture_count,
     const String& pattern) {
   macro_assembler->set_slow_safe(false /* use_slow_safe_regexp_compiler */);
   macro_assembler_ = macro_assembler;
 
@@ skipping 4381 matching lines @@
   if (offset >= bm->length()) {
     if (initial_offset == 0) set_bm_info(not_at_start, bm);
     return;
   }
   on_success()->FillInBMInfo(offset, budget - 1, bm,
                              true);  // Not at start after a text node.
   if (initial_offset == 0) set_bm_info(not_at_start, bm);
 }
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 RegExpEngine::CompilationResult RegExpEngine::CompileIR(
     RegExpCompileData* data,
     const ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     intptr_t osr_id) {
   ASSERT(!FLAG_interpret_irregexp);
   Zone* zone = Thread::Current()->zone();
 
   const Function& function = parsed_function->function();
   const intptr_t specialization_cid = function.string_specialization_cid();
@@ skipping 88 matching lines @@
 
   RegExpEngine::CompilationResult result =
       compiler.Assemble(macro_assembler, node, data->capture_count, pattern);
 
   if (FLAG_trace_irregexp) {
     macro_assembler->PrintBlocks();
   }
 
   return result;
 }
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
 
 RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(
     RegExpCompileData* data,
     const RegExp& regexp,
     bool is_one_byte,
     bool is_sticky,
     Zone* zone) {
   ASSERT(FLAG_interpret_irregexp);
   const String& pattern = String::Handle(zone, regexp.pattern());
@@ skipping 173 matching lines @@
       CreateSpecializedFunction(thread, zone, regexp, cid, /*sticky=*/true,
                                 owner);
     }
   }
 
   return regexp.raw();
 }
 
 
 }  // namespace dart