Observatory Display PC descriptors with disassembling

runtime/bin/vmservice/client/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;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   /// The owner of this [ServiceObject].  This can be an [Isolate], a
@@ skipping 846 matching lines @@
   @observable int firstTokenPos;
   @observable int lastTokenPos;
   bool get canCache => true;
   bool get immutable => true;
 
   String _shortUrl;
   String _url;
 
   Script._empty(ServiceObjectOwner owner) : super._empty(owner);
 
+  ScriptLine getLine(int line) {
+    assert(line >= 1);
+    return lines[line - 1];
+  }
+
   /// This function maps a token position to a line number.
   int tokenToLine(int token) => _tokenToLine[token];
   Map _tokenToLine;
 
   /// This function maps a token position to a column number.
   int tokenToCol(int token) => _tokenToCol[token];
   Map _tokenToCol;
 
   void _update(ObservableMap map, bool mapIsRef) {
     kind = map['kind'];
@@ skipping 68 matching lines @@
 }
 
 class CodeTick {
   final int address;
   final int exclusiveTicks;
   final int inclusiveTicks;
   CodeTick(this.address, this.exclusiveTicks, this.inclusiveTicks);
 }
 
 
+class PcDescriptor extends Observable {
+  final int address;
+  @reflectable final int deoptId;
+  @reflectable final int tokenPos;
+  @reflectable final int tryIndex;
+  @reflectable final String kind;
+  @observable Script script;
+  @observable String formattedLine;
+  PcDescriptor(this.address, this.deoptId, this.tokenPos, this.tryIndex,
+               this.kind);
+
+  @reflectable String formattedDeoptId() {
+    if (deoptId == -1) {
+      return 'N/A';
+    }
+    return deoptId.toString();
+  }
+
+  @reflectable String formattedTokenPos() {
+    if (tokenPos == -1) {
+      return '';
+    }
+    return tokenPos.toString();
+  }
+
+  void processScript(Script script) {
+    this.script = null;
+    if (tokenPos == -1) {
+      return;
+    }
+    var line = script.tokenToLine(tokenPos);
+    if (line == null) {
+      return;
+    }
+    this.script = script;
+    var scriptLine = script.getLine(line);
+    formattedLine = scriptLine.text;
+  }
+}
+
 class CodeInstruction extends Observable {
   @observable final int address;
   @observable final String machine;
   @observable final String human;
+  @observable CodeInstruction jumpTarget;
+  @reflectable List<PcDescriptor> descriptors =
+      new ObservableList<PcDescriptor>();
 
   static String formatPercent(num a, num total) {
     var percent = 100.0 * (a / total);
     return '${percent.toStringAsFixed(2)}%';
   }
 
   CodeInstruction(this.address, this.machine, this.human);
 
+  @reflectable bool get isComment => address == 0;
+  @reflectable bool get hasDescriptors => descriptors.length > 0;
+
   @reflectable String formattedAddress() {
     if (address == 0) {
       return '';
     }
     return '0x${address.toRadixString(16)}';
   }
 
   @reflectable String formattedInclusive(Code code) {
     if (code == null) {
       return '';
@@ skipping 14 matching lines @@
     if (code == null) {
       return '';
     }
     var tick = code.addressTicks[address];
     if (tick == null) {
       return '';
     }
     var pcent = formatPercent(tick.exclusiveTicks, code.totalSamplesInProfile);
     return '$pcent (${tick.exclusiveTicks})';
   }
+
+  bool _isJumpInstruction() {
+    return human.startsWith('j');
+  }
+
+  int _getJumpAddress() {
+    assert(_isJumpInstruction());
+    var chunks = human.split(' ');
+    if (chunks.length != 2) {
+      // We expect jump instructions to be of the form 'j.. address'.
+      return 0;
+    }
+    var address = chunks[1];
+    if (address.startsWith('0x')) {
+      // Chop off the 0x.
+      address = address.substring(2);
+    }
+    try {
+      return int.parse(address, radix:16);
+    } catch (_) {
+      return 0;
+    }
+  }
+
+  void _resolveJumpTarget(List<CodeInstruction> instructions) {
+    if (!_isJumpInstruction()) {
+      return;
+    }
+    int address = _getJumpAddress();
+    if (address == 0) {
+      // Could not determine jump address.
+      print('Could not determine jump address for $human');
+      return;
+    }
+    for (var i = 0; i < instructions.length; i++) {
+      var instruction = instructions[i];
+      if (instruction.address == address) {
+        jumpTarget = instruction;
+        return;
+      }
+    }
+    print('Could not find instruction at ${address.toRadixString(16)}');
+  }
 }
 
 class CodeKind {
   final _value;
   const CodeKind._internal(this._value);
   String toString() => '$_value';
 
   static CodeKind fromString(String s) {
     if (s == 'Native') {
       return Native;
@@ skipping 38 matching lines @@
   @reflectable int startAddress = 0;
   @reflectable int endAddress = 0;
   @reflectable final callers = new List<CodeCallCount>();
   @reflectable final callees = new List<CodeCallCount>();
   @reflectable final instructions = new ObservableList<CodeInstruction>();
   @reflectable final addressTicks = new ObservableMap<int, CodeTick>();
   @observable String formattedInclusiveTicks = '';
   @observable String formattedExclusiveTicks = '';
   @observable ServiceMap objectPool;
   @observable ServiceMap function;
+  @observable Script script;
   String name;
   String vmName;
 
   bool get canCache => true;
   bool get immutable => true;
 
   Code._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   // Reset all data associated with a profile.
   void resetProfileData() {
     totalSamplesInProfile = 0;
     exclusiveTicks = 0;
     inclusiveTicks = 0;
     formattedInclusiveTicks = '';
     formattedExclusiveTicks = '';
     callers.clear();
     callees.clear();
     addressTicks.clear();
   }
 
+  void _updateDescriptors(Script script) {
+    this.script = script;
+    for (var instruction in instructions) {
+      for (var descriptor in instruction.descriptors) {
+        descriptor.processScript(script);
+      }
+    }
+  }
+
+  void loadScript() {
+    if (script != null) {
+      // Already done.
+      return;
+    }
+    if (kind != CodeKind.Dart){
+      return;
+    }
+    if (function == null) {
+      return;
+    }
+    if (function['script'] == null) {
+      // Attempt to load the function.
+      function.load().then((func) {
+        var script = function['script'];
+        if (script == null) {
+          // Function doesn't have an associated script.
+          return;
+        }
+        // Load the script and then update descriptors.
+        script.load().then(_updateDescriptors);
+      });
+      return;
+    }
+    // Load the script and then update descriptors.
+    function['script'].load().then(_updateDescriptors);
+  }
+
   /// Reload [this]. Returns a future which completes to [this] or
   /// a [ServiceError].
   Future<ServiceObject> reload() {
     assert(kind != null);
     if (kind == CodeKind.Dart) {
       // We only reload Dart code.
       return super.reload();
     }
     return new Future.value(this);
   }
@@ skipping 48 matching lines @@
     vmName = m['name'];
     kind = CodeKind.fromString(m['kind']);
     startAddress = int.parse(m['start'], radix:16);
     endAddress = int.parse(m['end'], radix:16);
     function = isolate.getFromMap(m['function']);
     objectPool = isolate.getFromMap(m['object_pool']);
     var disassembly = m['disassembly'];
     if (disassembly != null) {
       _processDisassembly(disassembly);
     }
+    var descriptors = m['descriptors'];
+    if (descriptors != null) {
+      descriptors = descriptors['members'];
+      _processDescriptors(descriptors);
+    }
     // We are loaded if we have instructions or are not Dart code.
     _loaded = (instructions.length != 0) || (kind != CodeKind.Dart);
     hasDisassembly = (instructions.length != 0) && (kind == CodeKind.Dart);
   }
 
   @observable bool hasDisassembly = false;
 
   void _processDisassembly(List<String> disassembly){
     assert(disassembly != null);
     instructions.clear();
     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];
       if (disassembly[i] != '') {
         // Not a code comment, extract address.
         address = int.parse(disassembly[i]);
       }
       var instruction = new CodeInstruction(address, machine, human);
       instructions.add(instruction);
     }
+    for (var instruction in instructions) {
+      instruction._resolveJumpTarget(instructions);
+    }
+  }
+
+  void _processDescriptor(Map d) {
+    var address = int.parse(d['pc'], radix:16);
+    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) {
+        instruction.descriptors.add(new PcDescriptor(address,
+                                                     deoptId,
+                                                     tokenPos,
+                                                     tryIndex,
+                                                     kind));
+        return;
+      }
+    }
+    Logger.root.warning(
+        'Could not find instruction with pc descriptor address: $address');
+  }
+
+  void _processDescriptors(List<Map> descriptors) {
+    for (Map descriptor in descriptors) {
+      _processDescriptor(descriptor);
+    }
   }
 
   void _processTicks(List<String> profileTicks) {
     assert(profileTicks != null);
     assert((profileTicks.length % 3) == 0);
     for (var i = 0; i < profileTicks.length; i += 3) {
       var address = int.parse(profileTicks[i], radix:16);
       var exclusive = int.parse(profileTicks[i + 1]);
       var inclusive = int.parse(profileTicks[i + 2]);
       var tick = new CodeTick(address, exclusive, inclusive);
@@ skipping 75 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);
     }
   }
 }