pkg/native_stack_traces/lib/src/convert.dart - sdk.git - Git at Google

 // 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 'constants.dart' as constants;
 import 'dwarf.dart';

 String _stackTracePiece(CallInfo call, int depth) =>
     '#${depth.toString().padRight(6)} $call';

 // The initial header line in a non-symbolic stack trace.
 const _headerStartLine =
     '*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***';

 // A pattern matching the os/arch line of the non-symbolic stack trace header.
 //
 // This RegExp has been adjusted to parse the header line found in
 // non-symbolic stack traces and the modified version in signal handler stack
 // traces.
 final _osArchLineRE = RegExp(r'os(?:=|: )(\S+?),? '
     r'arch(?:=|: )(\S+?),? comp(?:=|: )(yes|no),? sim(?:=|: )(yes|no)');

 // A pattern matching the last line of the non-symbolic stack trace header.
 //
 // This RegExp has been adjusted to parse the header line found in
 // non-symbolic stack traces and the modified version in signal handler stack
 // traces.
 final _instructionsLineRE = RegExp(r'isolate_instructions(?:=|: )([\da-f]+),? '
     r'vm_instructions(?:=|: )([\da-f]+)');

 /// Header information for a non-symbolic Dart stack trace.
 class StackTraceHeader {
   String? _os;
   String? _arch;
   bool? _compressed;
   bool? _simulated;
   int? _isolateStart;
   int? _vmStart;

   String? get os => _os;
   String? get architecture => _arch;
   bool? get compressedPointers => _compressed;
   bool? get usingSimulator => _simulated;

   static StackTraceHeader fromStarts(int isolateStart, int vmStart) =>
       StackTraceHeader()
         .._isolateStart = isolateStart
         .._vmStart = vmStart;

   /// Try and parse the given line as one of the recognized lines in the
   /// header of a non-symbolic stack trace.
   ///
   /// Returns whether the line was recognized and parsed successfully.
   bool tryParseHeaderLine(String line) {
     if (line.contains(_headerStartLine)) {
       // This is the start of a new non-symbolic stack trace, so reset all the
       // stored information to be parsed anew.
       _os = null;
       _arch = null;
       _compressed = null;
       _simulated = null;
       _isolateStart = null;
       _vmStart = null;
       return true;
     }
     RegExpMatch? match = _osArchLineRE.firstMatch(line);
     if (match != null) {
       _os = match[1]!;
       _arch = match[2]!;
       _compressed = match[3]! == "yes";
       _simulated = match[4]! == "yes";
       // The architecture line always proceeds the instructions section line,
       // so reset these to null just in case we missed the header line.
       _isolateStart = null;
       _vmStart = null;
       return true;
     }
     match = _instructionsLineRE.firstMatch(line);
     if (match != null) {
       _isolateStart = int.parse(match[1]!, radix: 16);
       _vmStart = int.parse(match[2]!, radix: 16);
       return true;
     }
     return false;
   }

   /// The [PCOffset] for the given absolute program counter address.
   PCOffset? offsetOf(int address) {
     if (_isolateStart == null || _vmStart == null) return null;
     final isolateOffset = address - _isolateStart!;
     var vmOffset = address - _vmStart!;
     if (vmOffset > 0 && vmOffset == min(vmOffset, isolateOffset)) {
       return PCOffset(vmOffset, InstructionsSection.vm,
           os: _os,
           architecture: _arch,
           compressedPointers: _compressed,
           usingSimulator: _simulated);
     } else {
       return PCOffset(isolateOffset, InstructionsSection.isolate,
           os: _os,
           architecture: _arch,
           compressedPointers: _compressed,
           usingSimulator: _simulated);
     }
   }
 }

 /// 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 location of the virtual address, which is one of the following:
 ///     - A dynamic symbol name, a plus sign, and an integer offset.
 ///     - The path to the snapshot, if it was loaded as a dynamic library,
 ///       otherwise the string "<unknown>".
 const _symbolOffsetREString = r'(?<symbol>' +
     constants.vmSymbolName +
     r'|' +
     constants.isolateSymbolName +
     r')\+(?<offset>(?:0x)?[\da-f]+)';
 final _symbolOffsetRE = RegExp(_symbolOffsetREString);
 final _traceLineRE = RegExp(
     r'    #(\d+) abs (?<absolute>[\da-f]+)(?: virt (?<virtual>[\da-f]+))? '
     r'(?<rest>.*)$');

 /// Parses strings of the format <static symbol>+<integer offset>, where
 /// <static symbol> is one of the static symbols used for Dart instruction
 /// sections.
 ///
 /// Unless forceHexadecimal is true, an integer offset without a "0x" prefix or
 /// any hexdecimal digits will be parsed as decimal.
 ///
 /// Returns null if the string is not of the expected format.
 PCOffset? tryParseSymbolOffset(String s,
     {bool forceHexadecimal = false, StackTraceHeader? header}) {
   final match = _symbolOffsetRE.firstMatch(s);
   if (match == null) return null;
   final symbolString = match.namedGroup('symbol')!;
   final offsetString = match.namedGroup('offset')!;
   int? offset;
   if (!forceHexadecimal && !offsetString.startsWith('0x')) {
     offset = int.tryParse(offsetString);
   }
   if (offset == null) {
     final digits = offsetString.startsWith('0x')
         ? offsetString.substring(2)
         : offsetString;
     offset = int.tryParse(digits, radix: 16);
   }
   if (offset == null) return null;
   switch (symbolString) {
     case constants.vmSymbolName:
       return PCOffset(offset, InstructionsSection.vm,
           os: header?.os,
           architecture: header?.architecture,
           compressedPointers: header?.compressedPointers,
           usingSimulator: header?.usingSimulator);
     case constants.isolateSymbolName:
       return PCOffset(offset, InstructionsSection.isolate,
           os: header?.os,
           architecture: header?.architecture,
           compressedPointers: header?.compressedPointers,
           usingSimulator: header?.usingSimulator);
     default:
       break;
   }
   return null;
 }

 PCOffset? _retrievePCOffset(StackTraceHeader header, RegExpMatch? match) {
   if (match == null) return null;
   final restString = match.namedGroup('rest')!;
   // Try checking for symbol information first, since we don't need the header
   // information to translate it.
   if (restString.isNotEmpty) {
     final offset = tryParseSymbolOffset(restString, header: header);
     if (offset != null) return offset;
   }
   // If we're parsing the absolute address, we can only convert it into
   // a PCOffset if we saw the instructions line of the stack trace header.
   final addressString = match.namedGroup('absolute')!;
   final address = int.parse(addressString, radix: 16);
   final pcOffset = header.offsetOf(address);
   if (pcOffset != null) return pcOffset;
   // If all other cases failed, check for a virtual address. Until this package
   // depends on a version of Dart which only prints virtual addresses when the
   // virtual addresses in the snapshot are the same as in separately saved
   // debugging information, the other methods should be tried first.
   final virtualString = match.namedGroup('virtual');
   if (virtualString != null) {
     final address = int.parse(virtualString, radix: 16);
     return PCOffset(address, InstructionsSection.none,
         os: header.os,
         architecture: header.architecture,
         compressedPointers: header.compressedPointers,
         usingSimulator: header.usingSimulator);
   }
   return null;
 }

 /// The [PCOffset]s for frames of the non-symbolic stack traces in [lines].
 Iterable<PCOffset> collectPCOffsets(Iterable<String> lines) sync* {
   final header = StackTraceHeader();
   for (var line in lines) {
     if (header.tryParseHeaderLine(line)) {
       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;

   @override
   Stream<String> bind(Stream<String> stream) async* {
     var depth = 0;
     final header = StackTraceHeader();
     await for (final line in stream) {
       // If we successfully parse a header line, then we reset the depth to 0.
       if (header.tryParseHeaderLine(line)) {
         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++);
       }
     }
   }
 }
	// 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 'constants.dart' as constants;
	import 'dwarf.dart';

	String _stackTracePiece(CallInfo call, int depth) =>
	'#${depth.toString().padRight(6)} $call';

	// The initial header line in a non-symbolic stack trace.
	const _headerStartLine =
	'* * * * * * * * * * * * * * * *';

	// A pattern matching the os/arch line of the non-symbolic stack trace header.
	//
	// This RegExp has been adjusted to parse the header line found in
	// non-symbolic stack traces and the modified version in signal handler stack
	// traces.
	final _osArchLineRE = RegExp(r'os(?:=\|: )(\S+?),? '
	r'arch(?:=\|: )(\S+?),? comp(?:=\|: )(yes\|no),? sim(?:=\|: )(yes\|no)');

	// A pattern matching the last line of the non-symbolic stack trace header.
	//
	// This RegExp has been adjusted to parse the header line found in
	// non-symbolic stack traces and the modified version in signal handler stack
	// traces.
	final _instructionsLineRE = RegExp(r'isolate_instructions(?:=\|: )([\da-f]+),? '
	r'vm_instructions(?:=\|: )([\da-f]+)');

	/// Header information for a non-symbolic Dart stack trace.
	class StackTraceHeader {
	String? _os;
	String? _arch;
	bool? _compressed;
	bool? _simulated;
	int? _isolateStart;
	int? _vmStart;

	String? get os => _os;
	String? get architecture => _arch;
	bool? get compressedPointers => _compressed;
	bool? get usingSimulator => _simulated;

	static StackTraceHeader fromStarts(int isolateStart, int vmStart) =>
	StackTraceHeader()
	.._isolateStart = isolateStart
	.._vmStart = vmStart;

	/// Try and parse the given line as one of the recognized lines in the
	/// header of a non-symbolic stack trace.
	///
	/// Returns whether the line was recognized and parsed successfully.
	bool tryParseHeaderLine(String line) {
	if (line.contains(_headerStartLine)) {
	// This is the start of a new non-symbolic stack trace, so reset all the
	// stored information to be parsed anew.
	_os = null;
	_arch = null;
	_compressed = null;
	_simulated = null;
	_isolateStart = null;
	_vmStart = null;
	return true;
	}
	RegExpMatch? match = _osArchLineRE.firstMatch(line);
	if (match != null) {
	_os = match[1]!;
	_arch = match[2]!;
	_compressed = match[3]! == "yes";
	_simulated = match[4]! == "yes";
	// The architecture line always proceeds the instructions section line,
	// so reset these to null just in case we missed the header line.
	_isolateStart = null;
	_vmStart = null;
	return true;
	}
	match = _instructionsLineRE.firstMatch(line);
	if (match != null) {
	_isolateStart = int.parse(match[1]!, radix: 16);
	_vmStart = int.parse(match[2]!, radix: 16);
	return true;
	}
	return false;
	}

	/// The [PCOffset] for the given absolute program counter address.
	PCOffset? offsetOf(int address) {
	if (_isolateStart == null \|\| _vmStart == null) return null;
	final isolateOffset = address - _isolateStart!;
	var vmOffset = address - _vmStart!;
	if (vmOffset > 0 && vmOffset == min(vmOffset, isolateOffset)) {
	return PCOffset(vmOffset, InstructionsSection.vm,
	os: _os,
	architecture: _arch,
	compressedPointers: _compressed,
	usingSimulator: _simulated);
	} else {
	return PCOffset(isolateOffset, InstructionsSection.isolate,
	os: _os,
	architecture: _arch,
	compressedPointers: _compressed,
	usingSimulator: _simulated);
	}
	}
	}

	/// 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 location of the virtual address, which is one of the following:
	/// - A dynamic symbol name, a plus sign, and an integer offset.
	/// - The path to the snapshot, if it was loaded as a dynamic library,
	/// otherwise the string "<unknown>".
	const _symbolOffsetREString = r'(?<symbol>' +
	constants.vmSymbolName +
	r'\|' +
	constants.isolateSymbolName +
	r')\+(?<offset>(?:0x)?[\da-f]+)';
	final _symbolOffsetRE = RegExp(_symbolOffsetREString);
	final _traceLineRE = RegExp(
	r' #(\d+) abs (?<absolute>[\da-f]+)(?: virt (?<virtual>[\da-f]+))? '
	r'(?<rest>.*)$');

	/// Parses strings of the format <static symbol>+<integer offset>, where
	/// <static symbol> is one of the static symbols used for Dart instruction
	/// sections.
	///
	/// Unless forceHexadecimal is true, an integer offset without a "0x" prefix or
	/// any hexdecimal digits will be parsed as decimal.
	///
	/// Returns null if the string is not of the expected format.
	PCOffset? tryParseSymbolOffset(String s,
	{bool forceHexadecimal = false, StackTraceHeader? header}) {
	final match = _symbolOffsetRE.firstMatch(s);
	if (match == null) return null;
	final symbolString = match.namedGroup('symbol')!;
	final offsetString = match.namedGroup('offset')!;
	int? offset;
	if (!forceHexadecimal && !offsetString.startsWith('0x')) {
	offset = int.tryParse(offsetString);
	}
	if (offset == null) {
	final digits = offsetString.startsWith('0x')
	? offsetString.substring(2)
	: offsetString;
	offset = int.tryParse(digits, radix: 16);
	}
	if (offset == null) return null;
	switch (symbolString) {
	case constants.vmSymbolName:
	return PCOffset(offset, InstructionsSection.vm,
	os: header?.os,
	architecture: header?.architecture,
	compressedPointers: header?.compressedPointers,
	usingSimulator: header?.usingSimulator);
	case constants.isolateSymbolName:
	return PCOffset(offset, InstructionsSection.isolate,
	os: header?.os,
	architecture: header?.architecture,
	compressedPointers: header?.compressedPointers,
	usingSimulator: header?.usingSimulator);
	default:
	break;
	}
	return null;
	}

	PCOffset? _retrievePCOffset(StackTraceHeader header, RegExpMatch? match) {
	if (match == null) return null;
	final restString = match.namedGroup('rest')!;
	// Try checking for symbol information first, since we don't need the header
	// information to translate it.
	if (restString.isNotEmpty) {
	final offset = tryParseSymbolOffset(restString, header: header);
	if (offset != null) return offset;
	}
	// If we're parsing the absolute address, we can only convert it into
	// a PCOffset if we saw the instructions line of the stack trace header.
	final addressString = match.namedGroup('absolute')!;
	final address = int.parse(addressString, radix: 16);
	final pcOffset = header.offsetOf(address);
	if (pcOffset != null) return pcOffset;
	// If all other cases failed, check for a virtual address. Until this package
	// depends on a version of Dart which only prints virtual addresses when the
	// virtual addresses in the snapshot are the same as in separately saved
	// debugging information, the other methods should be tried first.
	final virtualString = match.namedGroup('virtual');
	if (virtualString != null) {
	final address = int.parse(virtualString, radix: 16);
	return PCOffset(address, InstructionsSection.none,
	os: header.os,
	architecture: header.architecture,
	compressedPointers: header.compressedPointers,
	usingSimulator: header.usingSimulator);
	}
	return null;
	}

	/// The [PCOffset]s for frames of the non-symbolic stack traces in [lines].
	Iterable<PCOffset> collectPCOffsets(Iterable<String> lines) sync* {
	final header = StackTraceHeader();
	for (var line in lines) {
	if (header.tryParseHeaderLine(line)) {
	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;

	@override
	Stream<String> bind(Stream<String> stream) async* {
	var depth = 0;
	final header = StackTraceHeader();
	await for (final line in stream) {
	// If we successfully parse a header line, then we reset the depth to 0.
	if (header.tryParseHeaderLine(line)) {
	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++);
	}
	}
	}
	}