| // Copyright (c) 2019, 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. |
| |
| import "dart:async"; |
| import "dart:math"; |
| |
| import "dwarf.dart"; |
| |
| String _stackTracePiece(CallInfo call, int depth) => "#${depth}\t${call}"; |
| |
| // A pattern matching the last line of the non-symbolic stack trace header. |
| // |
| // Currently, this happens to include the only pieces of information from the |
| // stack trace header we need: the absolute addresses during program |
| // execution of the start of the isolate and VM instructions. |
| final _headerEndRE = |
| RegExp(r'isolate_instructions: ([\da-f]+) vm_instructions: ([\da-f]+)$'); |
| |
| // Parses instructions section information into a new [StackTraceHeader]. |
| // |
| // Returns a new [StackTraceHeader] if [line] contains the needed header |
| // information, otherwise returns `null`. |
| StackTraceHeader _parseInstructionsLine(String line) { |
| final match = _headerEndRE.firstMatch(line); |
| if (match == null) return null; |
| final isolateAddr = int.parse(match[1], radix: 16); |
| final vmAddr = int.parse(match[2], radix: 16); |
| return StackTraceHeader(isolateAddr, vmAddr); |
| } |
| |
| /// Header information for a non-symbolic Dart stack trace. |
| class StackTraceHeader { |
| final int _isolateStart; |
| final int _vmStart; |
| |
| StackTraceHeader(this._isolateStart, this._vmStart); |
| |
| /// The [PCOffset] for the given absolute program counter address. |
| PCOffset offsetOf(int address) { |
| final isolateOffset = address - _isolateStart; |
| int vmOffset = address - _vmStart; |
| if (vmOffset > 0 && vmOffset == min(vmOffset, isolateOffset)) { |
| return PCOffset(vmOffset, InstructionsSection.vm); |
| } else { |
| return PCOffset(isolateOffset, InstructionsSection.isolate); |
| } |
| } |
| } |
| |
| /// A Dart DWARF stack trace contains up to four pieces of information: |
| /// - The zero-based frame index from the top of the stack. |
| /// - The absolute address of the program counter. |
| /// - The virtual address of the program counter, if the snapshot was |
| /// loaded as a dynamic library, otherwise not present. |
| /// - The path to the snapshot, if it was loaded as a dynamic library, |
| /// otherwise the string "<unknown>". |
| final _traceLineRE = |
| RegExp(r' #(\d{2}) abs ([\da-f]+)(?: virt ([\da-f]+))? (.*)$'); |
| |
| PCOffset _retrievePCOffset(StackTraceHeader header, Match match) { |
| if (header == null || match == null) return null; |
| final address = int.tryParse(match[2], radix: 16); |
| return header.offsetOf(address); |
| } |
| |
| /// The [PCOffset]s for frames of the non-symbolic stack traces in [lines]. |
| Iterable<PCOffset> collectPCOffsets(Iterable<String> lines) sync* { |
| StackTraceHeader header; |
| for (var line in lines) { |
| final parsedHeader = _parseInstructionsLine(line); |
| if (parsedHeader != null) { |
| header = parsedHeader; |
| continue; |
| } |
| final match = _traceLineRE.firstMatch(line); |
| final offset = _retrievePCOffset(header, match); |
| if (offset != null) yield offset; |
| } |
| } |
| |
| /// A [StreamTransformer] that scans lines for non-symbolic stack traces. |
| /// |
| /// A [NativeStackTraceDecoder] scans a stream of lines for non-symbolic |
| /// stack traces containing only program counter address information. Such |
| /// stack traces are generated by the VM when executing a snapshot compiled |
| /// with `--dwarf-stack-traces`. |
| /// |
| /// The transformer assumes that there may be text preceding the stack frames |
| /// on individual lines, like in log files, but that there is no trailing text. |
| /// For each stack frame found, the transformer attempts to locate a function |
| /// name, file name and line number using the provided DWARF information. |
| /// |
| /// If no information is found, or the line is not a stack frame, then the line |
| /// will be unchanged in the output stream. |
| /// |
| /// If the located information corresponds to Dart internals and |
| /// [includeInternalFrames] is false, then the output stream contains no |
| /// entries for the line. |
| /// |
| /// Otherwise, the output stream contains one or more lines with symbolic stack |
| /// frames for the given non-symbolic stack frame line. Multiple symbolic stack |
| /// frame lines are generated when the PC address corresponds to inlined code. |
| /// In the output stream, each symbolic stack frame is prefixed by the non-stack |
| /// frame portion of the original line. |
| class DwarfStackTraceDecoder extends StreamTransformerBase<String, String> { |
| final Dwarf _dwarf; |
| final bool _includeInternalFrames; |
| |
| DwarfStackTraceDecoder(this._dwarf, {bool includeInternalFrames = false}) |
| : _includeInternalFrames = includeInternalFrames; |
| |
| Stream<String> bind(Stream<String> stream) async* { |
| int depth = 0; |
| StackTraceHeader header; |
| await for (final line in stream) { |
| final parsedHeader = _parseInstructionsLine(line); |
| if (parsedHeader != null) { |
| header = parsedHeader; |
| depth = 0; |
| yield line; |
| continue; |
| } |
| // If at any point we can't get appropriate information for the current |
| // line as a stack trace line, then just pass the line through unchanged. |
| final lineMatch = _traceLineRE.firstMatch(line); |
| final offset = _retrievePCOffset(header, lineMatch); |
| final callInfo = offset?.callInfoFrom(_dwarf, |
| includeInternalFrames: _includeInternalFrames); |
| if (callInfo == null) { |
| yield line; |
| continue; |
| } |
| // No lines to output (as this corresponds to Dart internals). |
| if (callInfo.isEmpty) continue; |
| // Output the lines for the symbolic frame with the prefix found on the |
| // original non-symbolic frame line. |
| final prefix = line.substring(0, lineMatch.start); |
| for (final call in callInfo) { |
| yield prefix + _stackTracePiece(call, depth++); |
| } |
| } |
| } |
| } |