Include pattern and functions for RegExps over the service protocol. Remove quadratic behavior from…

runtime/observatory/lib/src/service/object.dart

 // 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.
 
 part of service;
 
 /// An RpcException represents an exceptional event that happened
 /// while invoking an rpc.
 abstract class RpcException implements Exception {
   RpcException(this.message);
@@ skipping 100 matching lines @@
   // Kinds of Instance.
   bool get isAbstractType => false;
   bool get isNull => false;
   bool get isBool => false;
   bool get isDouble => false;
   bool get isString => false;
   bool get isInt => false;
   bool get isList => false;
   bool get isMap => false;
   bool get isTypedData => false;
+  bool get isRegExp => false;
   bool get isMirrorReference => false;
   bool get isWeakProperty => false;
   bool get isClosure => false;
   bool get isPlainInstance => false;
 
   /// Has this object been fully loaded?
   bool get loaded => _loaded;
   bool _loaded = false;
   // TODO(turnidge): Make loaded observable and get rid of loading
   // from Isolate.
@@ skipping 1737 matching lines @@
   @observable String kind;
   @observable Class clazz;
   @observable int size;
   @observable int retainedSize;
   @observable String valueAsString;  // If primitive.
   @observable bool valueAsStringIsTruncated;
   @observable ServiceFunction function;  // If a closure.
   @observable Context context;  // If a closure.
   @observable String name;  // If a Type.
   @observable int length; // If a List, Map or TypedData.
+  @observable String pattern;  // If a RegExp.
 
   @observable var typeClass;
   @observable var fields;
   @observable var nativeFields;
   @observable var elements;  // If a List.
   @observable var associations;  // If a Map.
   @observable var typedElements;  // If a TypedData.
   @observable var referent;  // If a MirrorReference.
   @observable Instance key;  // If a WeakProperty.
   @observable Instance value;  // If a WeakProperty.
   @observable Breakpoint activationBreakpoint;  // If a Closure.
+  @observable Function oneByteFunction;  // If a RegExp.
+  @observable Function twoByteFunction;  // If a RegExp.
+  @observable Function externalOneByteFunction;  // If a RegExp.
+  @observable Function externalTwoByteFunction;  // If a RegExp.
 
   bool get isAbstractType {
     return (kind == 'Type' || kind == 'TypeRef' ||
             kind == 'TypeParameter' || kind == 'BoundedType');
   }
   bool get isNull => kind == 'Null';
   bool get isBool => kind == 'Bool';
   bool get isDouble => kind == 'Double';
   bool get isString => kind == 'String';
   bool get isInt => kind == 'Int';
   bool get isList => kind == 'List';
   bool get isMap => kind == 'Map';
   bool get isTypedData {
     return kind == 'Uint8ClampedList'
         || kind == 'Uint8List'
         || kind == 'Uint16List'
         || kind == 'Uint32List'
         || kind == 'Uint64List'
         || kind == 'Int8List'
         || kind == 'Int16List'
         || kind == 'Int32List'
         || kind == 'Int64List'
         || kind == 'Float32List'
         || kind == 'Float64List'
         || kind == 'Int32x4List'
         || kind == 'Float32x4List'
         || kind == 'Float64x2List';
   }
+  bool get isRegExp => kind == 'RegExp';
   bool get isMirrorReference => kind == 'MirrorReference';
   bool get isWeakProperty => kind == 'WeakProperty';
   bool get isClosure => kind == 'Closure';
 
   // TODO(turnidge): Is this properly backwards compatible when new
   // instance kinds are added?
   bool get isPlainInstance => kind == 'PlainInstance';
 
   Instance._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(ObservableMap map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     kind = map['kind'];
     clazz = map['class'];
     size = map['size'];
     valueAsString = map['valueAsString'];
     // Coerce absence to false.
     valueAsStringIsTruncated = map['valueAsStringIsTruncated'] == true;
     function = map['closureFunction'];
     context = map['closureContext'];
     name = map['name'];
     length = map['length'];
+    pattern = map['pattern'];
 
     if (mapIsRef) {
       return;
     }
 
+    oneByteFunction = map['_oneByteFunction'];
+    twoByteFunction = map['_twoByteFunction'];
+    externalOneByteFunction = map['_externalOneByteFunction'];
+    externalTwoByteFunction = map['_externalTwoByteFunction'];
+
     nativeFields = map['_nativeFields'];
     fields = map['fields'];
     elements = map['elements'];
     associations = map['associations'];
     if (map['bytes'] != null) {
       var bytes = decodeBase64(map['bytes']);
       switch (map['kind']) {
         case "Uint8ClampedList":
           typedElements = bytes.buffer.asUint8ClampedList(); break;
         case "Uint8List":
@@ skipping 844 matching lines @@
       // Chop off the 0x.
       address = address.substring(2);
     }
     try {
       return int.parse(address, radix:16);
     } catch (_) {
       return 0;
     }
   }
 
-  void _resolveJumpTarget(List<CodeInstruction> instructions) {
+  void _resolveJumpTarget(List<CodeInstruction> instructionsByAddressOffset,
+                          int startAddress) {
     if (!_isJumpInstruction()) {
       return;
     }
     int address = _getJumpAddress();
     if (address == 0) {
       return;
     }
-    for (var i = 0; i < instructions.length; i++) {
-      var instruction = instructions[i];
-      if (instruction.address == address) {
-        jumpTarget = instruction;
-        return;
-      }
-    }
+
+    jumpTarget = instructionsByAddressOffset[address - startAddress];
   }
 }
 
 class CodeKind {
   final _value;
   const CodeKind._internal(this._value);
   String toString() => '$_value';
   bool isSynthetic() => [Collected, Native, Tag].contains(this);
   bool isDart() => !isSynthetic();
   static CodeKind fromString(String s) {
@@ skipping 28 matching lines @@
 
 class Code extends ServiceObject {
   @observable CodeKind kind;
   @observable ServiceObject objectPool;
   @observable ServiceFunction function;
   @observable Script script;
   @observable bool isOptimized = false;
   @reflectable int startAddress = 0;
   @reflectable int endAddress = 0;
   @reflectable final instructions = new ObservableList<CodeInstruction>();
+  List<CodeInstruction> instructionsByAddressOffset;
+
   @observable ProfileCode profile;
   final List<CodeInlineInterval> inlineIntervals =
       new List<CodeInlineInterval>();
   final ObservableList<ServiceFunction> inlinedFunctions =
       new ObservableList<ServiceFunction>();
 
   bool get immutable => true;
 
   Code._empty(ServiceObjectOwner owner) : super._empty(owner);
 
@@ skipping 118 matching lines @@
       }
       inlineIntervals.add(codeInlineInterval);
     }
   }
 
   @observable bool hasDisassembly = false;
 
   void _processDisassembly(List<String> disassembly){
     assert(disassembly != null);
     instructions.clear();
+    instructionsByAddressOffset = new List(endAddress - startAddress);
+
     assert((disassembly.length % 3) == 0);
     for (var i = 0; i < disassembly.length; i += 3) {
       var address = 0;  // Assume code comment.
       var machine = disassembly[i + 1];
       var human = disassembly[i + 2];
       var pcOffset = 0;
       if (disassembly[i] != '') {
         // Not a code comment, extract address.
         address = int.parse(disassembly[i]);
         pcOffset = address - startAddress;
       }
       var instruction = new CodeInstruction(address, pcOffset, machine, human);
       instructions.add(instruction);
+      if (disassembly[i] != '') {
+        // Not a code comment.
+        instructionsByAddressOffset[pcOffset] = instruction;
+      }
     }
     for (var instruction in instructions) {
-      instruction._resolveJumpTarget(instructions);
+      instruction._resolveJumpTarget(instructionsByAddressOffset, startAddress);
     }
   }
 
-  void _processDescriptor(Map d) {
-    var pcOffset = int.parse(d['pcOffset'], radix:16);
-    var address = startAddress + pcOffset;
-    var deoptId = d['deoptId'];
-    var tokenPos = d['tokenPos'];
-    var tryIndex = d['tryIndex'];
-    var kind = d['kind'].trim();
-    for (var instruction in instructions) {
-      if (instruction.address == address) {
+  void _processDescriptors(List<Map> descriptors) {
+    for (Map descriptor in descriptors) {
+      var pcOffset = int.parse(descriptor['pcOffset'], radix:16);
+      var address = startAddress + pcOffset;
+      var deoptId = descriptor['deoptId'];
+      var tokenPos = descriptor['tokenPos'];
+      var tryIndex = descriptor['tryIndex'];
+      var kind = descriptor['kind'].trim();
+
+      var instruction = instructionsByAddressOffset[address - startAddress];
+      if (instruction != null) {
         instruction.descriptors.add(new PcDescriptor(pcOffset,
                                                      deoptId,
                                                      tokenPos,
                                                      tryIndex,
                                                      kind));
-        return;
+      } else {
+        Logger.root.warning(
+          'Could not find instruction with pc descriptor address: $address');
       }
     }
-    Logger.root.warning(
-        'Could not find instruction with pc descriptor address: $address');
-  }
-
-  void _processDescriptors(List<Map> descriptors) {
-    for (Map descriptor in descriptors) {
-      _processDescriptor(descriptor);
-    }
   }
 
   /// Returns true if [address] is contained inside [this].
   bool contains(int address) {
     return (address >= startAddress) && (address < endAddress);
   }
 
   @reflectable bool get isDartCode => (kind == CodeKind.Dart) ||
                                       (kind == CodeKind.Stub);
 
@@ skipping 286 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }