Revert r14252 as it broke --prof for some cases

tools/tickprocessor.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 152 matching lines @@
       'code-move': { parsers: [parseInt, parseInt],
           processor: this.processCodeMove },
       'code-delete': { parsers: [parseInt],
           processor: this.processCodeDelete },
       'sfi-move': { parsers: [parseInt, parseInt],
           processor: this.processFunctionMove },
       'snapshot-pos': { parsers: [parseInt, parseInt],
           processor: this.processSnapshotPosition },
       'tick': {
           parsers: [parseInt, parseInt, parseInt, parseInt,
-                    parseInt, 'var-args'],
+                    parseInt, parseInt, 'var-args'],
           processor: this.processTick },
       'heap-sample-begin': { parsers: [null, null, parseInt],
           processor: this.processHeapSampleBegin },
       'heap-sample-end': { parsers: [null, null],
           processor: this.processHeapSampleEnd },
       'timer-event-start' : { parsers: [null, null, null],
                               processor: this.advanceDistortion },
       'timer-event-end' : { parsers: [null, null, null],
                             processor: this.advanceDistortion },
       // Ignored events.
@@ skipping 177 matching lines @@
 };
 
 
 TickProcessor.prototype.includeTick = function(vmState) {
   return this.stateFilter_ == null || this.stateFilter_ == vmState;
 };
 
 TickProcessor.prototype.processTick = function(pc,
                                                sp,
                                                ns_since_start,
-                                               external_callback,
+                                               is_external_callback,
+                                               tos_or_external_callback,
                                                vmState,
                                                stack) {
   this.distortion += this.distortion_per_entry;
   ns_since_start -= this.distortion;
   if (ns_since_start < this.range_start || ns_since_start > this.range_end) {
     return;
   }
   this.ticks_.total++;
   if (vmState == TickProcessor.VmStates.GC) this.ticks_.gc++;
   if (!this.includeTick(vmState)) {
     this.ticks_.excluded++;
     return;
   }
-  if (external_callback) {
+  if (is_external_callback) {
     // Don't use PC when in external callback code, as it can point
     // inside callback's code, and we will erroneously report
     // that a callback calls itself. Instead we use tos_or_external_callback,
     // as simply resetting PC will produce unaccounted ticks.
-    pc = 0;
- }
+    pc = tos_or_external_callback;
+    tos_or_external_callback = 0;
+  } else if (tos_or_external_callback) {
+    // Find out, if top of stack was pointing inside a JS function
+    // meaning that we have encountered a frameless invocation.
+    var funcEntry = this.profile_.findEntry(tos_or_external_callback);
+    if (!funcEntry || !funcEntry.isJSFunction || !funcEntry.isJSFunction()) {
+      tos_or_external_callback = 0;
+    }
+  }
 
-  this.profile_.recordTick(this.processStack(pc, external_callback, stack));
+  this.profile_.recordTick(this.processStack(pc, tos_or_external_callback, stack));
 };
 
 
 TickProcessor.prototype.advanceDistortion = function() {
   this.distortion += this.distortion_per_entry;
 }
 
 
 TickProcessor.prototype.processHeapSampleBegin = function(space, state, ticks) {
   if (space != 'Heap') return;
@@ skipping 492 matching lines @@
       if (arg !== synArg && dispatch === this.argsDispatch_[synArg]) {
         synonims.push(synArg);
         delete this.argsDispatch_[synArg];
       }
     }
     print('  ' + padRight(synonims.join(', '), 20) + dispatch[2]);
   }
   quit(2);
 };