- Annotate instructions that load objects from the ObjectPool or Thread.

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;
 
 /// Helper function for canceling a Future<StreamSubscription>.
 Future cancelFutureSubscription(
     Future<StreamSubscription> subscriptionFuture) async {
   if (subscriptionFuture != null) {
@@ skipping 2550 matching lines @@
   // owner is a Library, Class, or ServiceFunction.
   @observable ServiceObject dartOwner;
   @observable Library library;
   @observable bool isStatic;
   @observable bool isConst;
   @observable SourceLocation location;
   @observable Code code;
   @observable Code unoptimizedCode;
   @observable bool isOptimizable;
   @observable bool isInlinable;
+  @observable bool hasIntrinsic;
+  @observable bool isRecognized;
+  @observable bool isNative;
   @observable FunctionKind kind;
   @observable int deoptimizations;
   @observable String qualifiedName;
   @observable int usageCounter;
   @observable bool isDart;
   @observable ProfileFunction profile;
   @observable Instance icDataArray;
   @observable Field field;
 
   bool get canCache => true;
@@ skipping 20 matching lines @@
     } else if (dartOwner is Class) {
       Class ownerClass = dartOwner;
       library = ownerClass.library;
       qualifiedName = "${ownerClass.name}.${name}";
 
     } else {
       library = dartOwner;
       qualifiedName = name;
     }
 
+    hasIntrinsic = map['_intrinsic'];
+    isNative = map['_native'];
+
     if (mapIsRef) {
       return;
     }
 
     _loaded = true;
     isStatic = map['static'];
     isConst = map['const'];
     location = map['location'];
     code = map['code'];
     isOptimizable = map['_optimizable'];
     isInlinable = map['_inlinable'];
+    isRecognized = map['_recognized'];
     unoptimizedCode = map['_unoptimizedCode'];
     deoptimizations = map['_deoptimizations'];
     usageCounter = map['_usageCounter'];
     icDataArray = map['_icDataArray'];
     field = map['_field'];
   }
 }
 
 
 class Field extends HeapObject {
@@ skipping 774 matching lines @@
     }
     privateKey = map['privateKey'];
   }
 }
 
 class CodeInstruction extends Observable {
   @observable final int address;
   @observable final int pcOffset;
   @observable final String machine;
   @observable final String human;
+  @observable final ServiceObject object;
   @observable CodeInstruction jumpTarget;
   @reflectable List<PcDescriptor> descriptors =
       new ObservableList<PcDescriptor>();
 
-  CodeInstruction(this.address, this.pcOffset, this.machine, this.human);
+  CodeInstruction(this.address,
+                  this.pcOffset,
+                  this.machine,
+                  this.human,
+                  this.object);
 
   @reflectable bool get isComment => address == 0;
   @reflectable bool get hasDescriptors => descriptors.length > 0;
 
   bool _isJumpInstruction() {
     return human.startsWith('j');
   }
 
   int _getJumpAddress() {
     assert(_isJumpInstruction());
@@ skipping 70 matching lines @@
   final List<ServiceFunction> functions = new List<ServiceFunction>();
   bool contains(int pc) => (pc >= start) && (pc < end);
   CodeInlineInterval(this.start, this.end);
 }
 
 class Code extends HeapObject {
   @observable CodeKind kind;
   @observable ServiceObject objectPool;
   @observable ServiceFunction function;
   @observable Script script;
-  @observable bool isOptimized = false;
+  @observable bool isOptimized;
+  @observable bool hasIntrinsic;
+  @observable bool isNative;
+
   @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>();
@@ skipping 49 matching lines @@
       return super.reload();
     }
     return new Future.value(this);
   }
 
   void _update(ObservableMap m, bool mapIsRef) {
     name = m['name'];
     vmName = (m.containsKey('_vmName') ? m['_vmName'] : name);
     isOptimized = m['_optimized'];
     kind = CodeKind.fromString(m['kind']);
+    hasIntrinsic = m['_intrinsic'];
+    isNative = m['_native'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     startAddress = int.parse(m['_startAddress'], radix:16);
     endAddress = int.parse(m['_endAddress'], radix:16);
     function = isolate.getFromMap(m['function']);
     objectPool = isolate.getFromMap(m['_objectPool']);
     var disassembly = m['_disassembly'];
     if (disassembly != null) {
@@ skipping 59 matching lines @@
     }
   }
 
   @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) {
+    assert((disassembly.length % 4) == 0);
+    for (var i = 0; i < disassembly.length; i += 4) {
       var address = 0;  // Assume code comment.
       var machine = disassembly[i + 1];
       var human = disassembly[i + 2];
+      var object = disassembly[i + 3];
+      if (object != null) {
+        object = new ServiceObject._fromMap(owner, object);
+      }
       var pcOffset = 0;
-      if (disassembly[i] != '') {
+      if (disassembly[i] != null) {
         // Not a code comment, extract address.
         address = int.parse(disassembly[i], radix:16);
         pcOffset = address - startAddress;
       }
-      var instruction = new CodeInstruction(address, pcOffset, machine, human);
+      var instruction =
+          new CodeInstruction(address, pcOffset, machine, human, object);
       instructions.add(instruction);
-      if (disassembly[i] != '') {
+      if (disassembly[i] != null) {
         // Not a code comment.
         instructionsByAddressOffset[pcOffset] = instruction;
       }
     }
     for (var instruction in instructions) {
       instruction._resolveJumpTarget(instructionsByAddressOffset, startAddress);
     }
   }
 
   void _processDescriptors(List<Map> descriptors) {
@@ skipping 316 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);
     }
   }
 }