Fix Observatory disassembly view

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;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
@@ skipping 679 matching lines @@
     collections = heapMap['collections'];
     totalCollectionTimeInSeconds = heapMap['time'];
     averageCollectionPeriodInMillis = heapMap['avgCollectionPeriodMillis'];
   }
 }
 
 class HeapSnapshot {
   final ObjectGraph graph;
   final DateTime timeStamp;
   final Isolate isolate;
-  
+
   HeapSnapshot(this.isolate, ByteData data) :
       graph = new ObjectGraph(new ReadStream(data)),
       timeStamp = new DateTime.now() {
   }
-  
+
   List<Future<ServiceObject>> getMostRetained({int classId, int limit}) {
     var result = [];
     for (var v in graph.getMostRetained(classId: classId, limit: limit)) {
       var address = v.addressForWordSize(isolate.vm.architectureBits ~/ 8);
       result.add(isolate.get(
           'address/${address.toRadixString(16)}?ref=true').then((obj) {
         obj.retainedSize = v.retainedSize;
         return new Future(() => obj);
       }));
     }
     return result;
   }
-  
-  
+
+
 }
 
 /// State for a running isolate.
 class Isolate extends ServiceObjectOwner with Coverage {
   @reflectable VM get vm => owner;
   @reflectable Isolate get isolate => this;
   @observable ObservableMap counters = new ObservableMap();
 
   String get link => '/${_id}';
 
@@ skipping 145 matching lines @@
       toObservable(new Map<String, double>());
 
   final HeapSpace newSpace = new HeapSpace();
   final HeapSpace oldSpace = new HeapSpace();
 
   @observable String fileAndLine;
 
   @observable DartError error;
   @observable HeapSnapshot latestSnapshot;
   Completer<HeapSnapshot> _snapshotFetch;
-  
+
   void loadHeapSnapshot(ServiceEvent event) {
     latestSnapshot = new HeapSnapshot(this, event.data);
     _snapshotFetch.complete(latestSnapshot);
   }
-  
+
   Future<HeapSnapshot> fetchHeapSnapshot() {
     if (_snapshotFetch == null || _snapshotFetch.isCompleted) {
       get('graph');
       _snapshotFetch = new Completer<HeapSnapshot>();
     }
     return _snapshotFetch.future;
   }
 
   void updateHeapsFromMap(ObservableMap map) {
     newSpace.update(map['new']);
@@ skipping 1118 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;
+  final int pcOffset;
   @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,
+  PcDescriptor(this.pcOffset, this.deoptId, this.tokenPos, this.tryIndex,
                this.kind);
 
   @reflectable String formattedDeoptId() {
     if (deoptId == -1) {
       return 'N/A';
     }
     return deoptId.toString();
   }
 
   @reflectable String formattedTokenPos() {
@@ skipping 20 matching lines @@
 
 class PcDescriptors extends ServiceObject {
   @observable Class clazz;
   @observable int size;
   bool get canCache => false;
   bool get immutable => true;
   @reflectable final List<PcDescriptor> descriptors =
       new ObservableList<PcDescriptor>();
 
   PcDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner) {
-    print('created PcDescriptors.');
   }
 
   void _update(ObservableMap m, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
     _upgradeCollection(m, isolate);
     clazz = m['class'];
     size = m['size'];
     descriptors.clear();
     for (var descriptor in m['members']) {
-      var address = int.parse(descriptor['pc'], radix:16);
+      var pcOffset = int.parse(descriptor['pcOffset'], radix:16);
       var deoptId = descriptor['deoptId'];
       var tokenPos = descriptor['tokenPos'];
       var tryIndex = descriptor['tryIndex'];
       var kind = descriptor['kind'].trim();
       descriptors.add(
-          new PcDescriptor(address, deoptId, tokenPos, tryIndex, kind));
+          new PcDescriptor(pcOffset, deoptId, tokenPos, tryIndex, kind));
     }
   }
 }
 
 class LocalVarDescriptor extends Observable {
   @reflectable final String name;
   @reflectable final int index;
   @reflectable final int beginPos;
   @reflectable final int endPos;
   @reflectable final int scopeId;
@@ skipping 49 matching lines @@
     }
     _upgradeCollection(m, isolate);
     clazz = m['class'];
     size = m['size'];
     privateKey = m['privateKey'];
   }
 }
 
 class CodeInstruction extends Observable {
   @observable final int address;
+  @observable final int pcOffset;
   @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);
+  CodeInstruction(this.address, this.pcOffset, 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)}';
   }
@@ skipping 266 matching lines @@
   @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];
+      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, machine, human);
+      var instruction = new CodeInstruction(address, pcOffset, 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 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) {
-        instruction.descriptors.add(new PcDescriptor(address,
+        instruction.descriptors.add(new PcDescriptor(pcOffset,
                                                      deoptId,
                                                      tokenPos,
                                                      tryIndex,
                                                      kind));
         return;
       }
     }
     Logger.root.warning(
         'Could not find instruction with pc descriptor address: $address');
   }
@@ skipping 292 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);
     }
   }
 }