- Refactor Symbol allocation to expect a thread parameter.

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"
@@ skipping 5226 matching lines @@
                         pattern);
 
   if (FLAG_trace_irregexp) {
     macro_assembler->PrintBlocks();
   }
 
   return result;
 }
 
 
-static void CreateSpecializedFunction(Zone* zone,
+static void CreateSpecializedFunction(Thread* thread, Zone* zone,
                                       const RegExp& regexp,
                                       intptr_t specialization_cid,
                                       const Object& owner) {
   const intptr_t kParamCount = RegExpMacroAssembler::kParamCount;
 
   Function& fn = Function::Handle(zone, Function::New(
       // Append the regexp pattern to the function name.
-      String::Handle(zone, Symbols::New(
+      String::Handle(zone, Symbols::New(thread,
           String::Handle(zone, String::Concat(
               String::Handle(zone, String::Concat(
                   Symbols::ColonMatcher(),
                   Symbols::ColonSpace(), Heap::kOld)),
               String::Handle(regexp.pattern()), Heap::kOld)))),
       RawFunction::kIrregexpFunction,
       true,  // Static.
       false,  // Not const.
       false,  // Not abstract.
       false,  // Not external.
@@ skipping 24 matching lines @@
   // Cache the result.
   regexp.set_function(specialization_cid, fn);
 
   fn.SetRegExpData(regexp, specialization_cid);
   fn.set_is_debuggable(false);
 
   // The function is compiled lazily during the first call.
 }
 
 
-RawRegExp* RegExpEngine::CreateRegExp(Zone* zone,
-                                          const String& pattern,
-                                          bool multi_line,
-                                          bool ignore_case) {
+RawRegExp* RegExpEngine::CreateRegExp(Thread* thread,
+                                      const String& pattern,
+                                      bool multi_line,
+                                      bool ignore_case) {
+  Zone* zone = thread->zone();
   const RegExp& regexp = RegExp::Handle(RegExp::New());
 
   regexp.set_pattern(pattern);
 
   if (multi_line) {
     regexp.set_is_multi_line();
   }
   if (ignore_case) {
     regexp.set_is_ignore_case();
   }
 
   // TODO(zerny): We might want to use normal string searching algorithms
   // for simple patterns.
   regexp.set_is_complex();
   regexp.set_is_global();   // All dart regexps are global.
 
   if (!FLAG_interpret_irregexp) {
     const Library& lib = Library::Handle(zone, Library::CoreLibrary());
-    const Class& owner = Class::Handle(
-        zone, lib.LookupClass(Symbols::RegExp()));
+    const Class& owner = Class::Handle(zone,
+                                       lib.LookupClass(Symbols::RegExp()));
 
-    CreateSpecializedFunction(zone, regexp, kOneByteStringCid, owner);
-    CreateSpecializedFunction(zone, regexp, kTwoByteStringCid, owner);
-    CreateSpecializedFunction(zone, regexp, kExternalOneByteStringCid, owner);
-    CreateSpecializedFunction(zone, regexp, kExternalTwoByteStringCid, owner);
+    CreateSpecializedFunction(thread, zone, regexp, kOneByteStringCid, owner);
+    CreateSpecializedFunction(thread, zone, regexp, kTwoByteStringCid, owner);
+    CreateSpecializedFunction(thread, zone,
+                              regexp, kExternalOneByteStringCid, owner);
+    CreateSpecializedFunction(thread, zone,
+                              regexp, kExternalTwoByteStringCid, owner);
   }
 
   return regexp.raw();
 }
 
 
 }  // namespace dart