| // Copyright (c) 2020, 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. |
| |
| /// Symbolizer functionality |
| library symbolizer.symbolizer; |
| |
| import 'dart:async'; |
| import 'dart:io'; |
| |
| import 'package:collection/collection.dart' show IterableExtension; |
| import 'package:http/http.dart' as http; |
| import 'package:logging/logging.dart'; |
| import 'package:path/path.dart' as p; |
| import 'package:github/github.dart'; |
| |
| import 'package:symbolizer/model.dart'; |
| import 'package:symbolizer/ndk.dart'; |
| import 'package:symbolizer/parser.dart'; |
| import 'package:symbolizer/symbols.dart'; |
| |
| final _log = Logger('symbolizer'); |
| |
| class Symbolizer { |
| final SymbolsCache symbols; |
| final Ndk ndk; |
| final GitHub github; |
| final CrashExtractor crashExtractor; |
| |
| Symbolizer({ |
| required this.symbols, |
| required this.ndk, |
| required this.github, |
| this.crashExtractor = const CrashExtractor(), |
| }); |
| |
| Future<SymbolizationResult> symbolize(String text, |
| {SymbolizationOverrides? overrides}) async { |
| try { |
| return SymbolizationResult.ok( |
| results: await _symbolizeImpl(text, overrides: overrides)); |
| } catch (e, st) { |
| return SymbolizationResult.error( |
| error: SymbolizationNote( |
| kind: SymbolizationNoteKind.exceptionWhileParsing, |
| message: '$e\n$st')); |
| } |
| } |
| |
| /// Process the given [text] to find all crashes and symbolize them. |
| Future<List<CrashSymbolizationResult>> _symbolizeImpl(String text, |
| {SymbolizationOverrides? overrides}) async { |
| final crashes = crashExtractor.extractCrashes(text, overrides: overrides); |
| if (crashes.isEmpty) { |
| return []; |
| } |
| |
| // First compute engine hash to use for symbolization. |
| String? engineHash; |
| try { |
| engineHash = await _guessEngineHash(text, overrides); |
| } catch (e, st) { |
| return _failedToSymbolizeAll( |
| crashes, SymbolizationNoteKind.exceptionWhileGettingEngineHash, |
| error: '$e\n$st'); |
| } |
| if (engineHash == null) { |
| return _failedToSymbolizeAll( |
| crashes, SymbolizationNoteKind.unknownEngineHash); |
| } |
| |
| final result = <CrashSymbolizationResult>[]; |
| for (var crash in crashes) { |
| try { |
| result.add(await _symbolizeCrash(crash, engineHash, overrides)); |
| } catch (e, st) { |
| result.add(_failedToSymbolize( |
| crash, SymbolizationNoteKind.exceptionWhileSymbolizing, |
| error: '$e\n$st')); |
| } |
| } |
| return result; |
| } |
| |
| Future<String?> _guessEngineHash( |
| String text, SymbolizationOverrides? overrides) async { |
| // Try to establish engine hash based on the content. |
| var engineHash = overrides?.engineHash ?? |
| _reEngineHash.firstMatch(text)?.namedGroup('shortHash'); |
| if (engineHash == null && overrides?.flutterVersion != null) { |
| engineHash = |
| await _engineHashFromFlutterVersion(overrides!.flutterVersion); |
| } |
| if (engineHash != null) { |
| // Try to expand short hash into full hash. |
| final engineCommit = await github.repositories |
| .getCommit(RepositorySlug('flutter', 'engine'), engineHash); |
| engineHash = engineCommit.sha; |
| } |
| if (engineHash == null) { |
| // Try to establish engineHash based on Flutter version |
| final m = _reFlutterVersion.firstMatch(text); |
| if (m != null && m.namedGroup('channel') != 'master') { |
| // Try to use version tag. |
| final tag = m.namedGroup('version'); |
| engineHash = await _engineHashFromFlutterVersion(tag); |
| } |
| } |
| return engineHash; |
| } |
| |
| Future<String?> _engineHashFromFlutterVersion(String? version) async { |
| final response = await http.get(Uri.parse( |
| 'https://raw.githubusercontent.com/flutter/flutter/$version/bin/internal/engine.version')); |
| if (response.statusCode == HttpStatus.ok) { |
| return response.body.trim(); |
| } |
| return null; |
| } |
| |
| Future<CrashSymbolizationResult> _symbolizeCrashWith( |
| Crash crash, EngineBuild engineBuild) async { |
| try { |
| final symbolsDir = await symbols.get(engineBuild); |
| return await _symbolizeCrashWithGivenSymbols( |
| crash, symbolsDir, engineBuild); |
| } catch (e, st) { |
| return _failedToSymbolize( |
| crash, SymbolizationNoteKind.exceptionWhileSymbolizing, |
| error: '{$engineBuild} $e\n$st'); |
| } |
| } |
| |
| Future<CrashSymbolizationResult> _symbolizeCrash( |
| Crash crash, String engineHash, SymbolizationOverrides? overrides) async { |
| // Apply overrides |
| if (crash.engineVariant.arch == null) { |
| return _failedToSymbolize(crash, SymbolizationNoteKind.unknownAbi); |
| } |
| |
| EngineBuild engineBuild; |
| |
| final buildId = _findBuildIdInFrames(crash.frames); |
| // Even if buildId is available we don't use it for matching |
| // if mode was found heuristically or was specified through overrides |
| // already. |
| if (crash.engineVariant.mode != null || |
| overrides?.mode != null || |
| buildId == null) { |
| // Currently on iOS we only have symbols for release builds. |
| if (crash.engineVariant.os == 'ios') { |
| if (crash.engineVariant.mode != 'release') { |
| return _failedToSymbolize( |
| crash, SymbolizationNoteKind.noSymbolsAvailableOnIos); |
| } |
| } |
| |
| engineBuild = EngineBuild( |
| engineHash: engineHash, |
| variant: crash.engineVariant.copyWith( |
| mode: crash.engineVariant.mode ?? overrides?.mode ?? 'release'), |
| ); |
| |
| // Note: on iOS build ids (LC_UUID) don't seem to match between |
| // archived dSYMs and what users report, so we can't rely on them |
| // for matching dSYMs to crash reports. |
| } else { |
| try { |
| engineBuild = await symbols.findVariantByBuildId( |
| variant: crash.engineVariant, |
| engineHash: engineHash, |
| buildId: buildId); |
| } catch (e) { |
| return _failedToSymbolize( |
| crash, SymbolizationNoteKind.exceptionWhileLookingByBuildId, |
| error: 'build-id: $buildId\n$e'); |
| } |
| } |
| |
| var result = await _symbolizeCrashWith(crash, engineBuild); |
| |
| if (result.symbolized != null && |
| buildId == null && |
| overrides?.mode == null && |
| (crash.engineVariant.mode == null || |
| crash.engineVariant.mode != 'release')) { |
| result = result |
| .withNote(SymbolizationNoteKind.defaultedToReleaseBuildIdUnavailable); |
| } |
| |
| // We might have used wrong symbols for symbolization (because we were |
| // forced or because our heuristics failed for some reason). |
| if (buildId != null) { |
| final symbolsDir = await symbols.get(engineBuild); |
| final engineBuildId = |
| await ndk.getBuildId(p.join(symbolsDir, 'libflutter.so')); |
| if (engineBuildId != buildId) { |
| result = result.withNote(SymbolizationNoteKind.buildIdMismatch, |
| 'Backtrace refers to $buildId but we used engine with $engineBuildId'); |
| } |
| } |
| |
| return result; |
| } |
| |
| static String? _findBuildIdInFrames(List<CrashFrame> frames) => frames |
| .whereType<AndroidCrashFrame>() |
| .firstWhereOrNull((frame) => |
| frame.binary.endsWith('libflutter.so') && frame.buildId != null) |
| ?.buildId; |
| |
| Future<CrashSymbolizationResult> _symbolizeCrashWithGivenSymbols( |
| Crash crash, String symbolsDir, EngineBuild build) { |
| final result = CrashSymbolizationResult( |
| engineBuild: build, crash: crash, symbolized: null); |
| if (crash.format == 'dartvm') { |
| return _symbolizeDartvmFrames( |
| result, |
| crash.frames.cast<DartvmCrashFrame>(), |
| crash.engineVariant.arch, |
| symbolsDir, |
| ); |
| } else if (crash.format == 'custom') { |
| return _symbolizeCustomFrames( |
| result, |
| crash.frames.cast<CustomCrashFrame>(), |
| crash.engineVariant.arch, |
| build, |
| symbolsDir, |
| ); |
| } else if (crash.engineVariant.os == 'android') { |
| return _symbolizeAndroidFrames( |
| result, |
| crash.frames.cast<AndroidCrashFrame>(), |
| crash.engineVariant.arch, |
| symbolsDir, |
| crash.androidMajorVersion, |
| ); |
| } else { |
| return _symbolizeIosFrames( |
| result, |
| crash.frames.cast<IosCrashFrame>(), |
| crash.engineVariant.arch, |
| build, |
| symbolsDir, |
| ); |
| } |
| } |
| |
| Future<CrashSymbolizationResult> |
| _symbolizeGeneric<FrameType extends CrashFrame>({ |
| required CrashSymbolizationResult result, |
| required List<FrameType> frames, |
| required String? arch, |
| required String object, |
| required bool Function(FrameType) shouldSymbolize, |
| required int Function(FrameType) getRelativePC, |
| required FutureOr<int> Function(Iterable<FrameType>) computePCBias, |
| required String Function(FrameType) frameSuffix, |
| required bool shouldAdjustInnerPCs, |
| }) async { |
| _log.info('Symbolizing using $object'); |
| |
| final worklist = <int>{}; |
| |
| // First collect Flutter Engine frames. |
| final binaryName = p.basename(object); |
| for (var i = 0; i < frames.length; i++) { |
| if (frames[i].binary.endsWith(binaryName) && shouldSymbolize(frames[i])) { |
| worklist.add(i); |
| } |
| } |
| |
| final symbolized = <int, String>{}; |
| if (worklist.isNotEmpty) { |
| final vmaBias = await computePCBias(worklist.map((i) => frames[i])); |
| symbolized.addAll(Map.fromIterables( |
| worklist, |
| await ndk.symbolize( |
| object: object, |
| arch: arch, |
| addresses: worklist |
| .map((i) { |
| return getRelativePC(frames[i]) + |
| vmaBias + |
| (shouldAdjustInnerPCs && i > 0 ? -1 : 0); |
| }) |
| .map(_asHex) |
| .toList()))); |
| } |
| |
| // Assemble the result. |
| final pcSize = _pointerSize(arch); |
| final buf = StringBuffer(); |
| for (var i = 0; i < frames.length; i++) { |
| final frame = frames[i]; |
| final prefix = |
| '#${i.toString().padLeft(2, '0')} ${_addrHex(frame.pc, pcSize)} ${_shortBinaryName(frame.binary)}'; |
| buf.write(prefix); |
| buf.writeln(frameSuffix(frame)); |
| if (worklist.contains(i)) { |
| final indent = ' ' * (prefix.length + 1); |
| for (var line in symbolized[i]!.split('\n')) { |
| buf.write(indent); |
| buf.writeln(line); |
| } |
| } |
| } |
| |
| return result.copyWith(symbolized: buf.toString()); |
| } |
| |
| Future<CrashSymbolizationResult> _symbolizeAndroidFrames( |
| CrashSymbolizationResult result, |
| List<AndroidCrashFrame> frames, |
| String? arch, |
| String symbolsDir, |
| int? androidMajorVersion, |
| ) async { |
| final flutterSo = p.join(symbolsDir, 'libflutter.so'); |
| return _symbolizeGeneric<AndroidCrashFrame>( |
| result: result, |
| frames: frames, |
| arch: arch, |
| object: flutterSo, |
| shouldSymbolize: (_) => true, |
| getRelativePC: (frame) => frame.pc, |
| shouldAdjustInnerPCs: false, // Android unwinder already adjusted it. |
| computePCBias: (frames) async { |
| if ((androidMajorVersion ?? 0) >= 11) { |
| return 0; |
| } |
| // Prior to Android 11 backtraces printed by debuggerd contained PCs |
| // which can't be directly used for symbolization. Very old versions |
| // of Android printed offsets into RX mapping, while newer versions |
| // printed ELF file offsets. We try to differentiate between these two |
| // situations by checking if any PCs are outside of .text section range. |
| // In both cases we can't directly use this PC for symbolization because |
| // it does not necessarily match VMAs used in the ELF file (which is |
| // what llvm-symbolizer would need for symbolization). |
| final textSection = await ndk.getTextSectionInfo(flutterSo); |
| final textStart = textSection.fileOffset; |
| final textEnd = textSection.fileOffset + textSection.fileSize; |
| final likelySectionOffset = |
| !frames.every((f) => textStart <= f.pc && f.pc < textEnd); |
| return likelySectionOffset |
| ? (textSection.virtualAddress & ~0xfff) |
| : (textSection.virtualAddress - textSection.fileOffset); |
| }, |
| frameSuffix: (frame) => ' ${frame.rest.trimLeft()}', |
| ); |
| } |
| |
| Future<CrashSymbolizationResult> _symbolizeDartvmFrames( |
| CrashSymbolizationResult result, |
| List<DartvmCrashFrame> frames, |
| String? arch, |
| String symbolsDir) async { |
| final flutterSo = p.join(symbolsDir, 'libflutter.so'); |
| return _symbolizeGeneric<DartvmCrashFrame>( |
| result: result, |
| frames: frames, |
| arch: arch, |
| object: flutterSo, |
| shouldSymbolize: (_) => true, |
| getRelativePC: (frame) => frame.offset, |
| shouldAdjustInnerPCs: true, |
| computePCBias: (frames) async { |
| // For now we assume that we only get Dart VM crash stacks from Android. |
| // |
| // There we get output like libflutter.so+offset where offset is |
| // PC minus base of libflutter.so (as returned by dladdr), which |
| // corresponds to the address of the first page mapped from ELF file. |
| // |
| // Important thing to note here is that RX mapping would use aligned |
| // file offset (textSection.fileOffset & ~pageMask). This might increase |
| // the distance between SO base and PC by 1 page if testSection.fileOffset |
| // is not aligned: |
| // |
| // RO RX PC |
| // [ ][ * ] |
| // | | |
| // B B + fileOffset |
| // 0 |
| // |
| // If fileOffset is misaligned then subtracting B from PC does not yield |
| // file offset corresponding to the PC, but rather file offset plus |
| // pageSize, so we need to accomodate for that in VMA adjustment. |
| const pageSize = 4096; |
| const pageMask = pageSize - 1; |
| |
| final textSection = await ndk.getTextSectionInfo(flutterSo); |
| final loadBias = textSection.virtualAddress - textSection.fileOffset; |
| return loadBias - |
| (((textSection.fileOffset & pageMask) + pageMask) & ~pageMask); |
| }, |
| frameSuffix: (frame) => '+${_asHex(frame.offset)}', |
| ); |
| } |
| |
| /// Pattern for extracting information from ARM64 objdump output. |
| static final _objdumpPattern = |
| RegExp(r'^\s*(?<addr>[a-f0-9]+):\s+([a-f0-9]{2}\s+){4}(?<op>\w+)'); |
| |
| /// Extract information about calls (branch-link instruction) locations |
| /// in the binary. |
| Future<_CallLocations?> _determineCallLocations(EngineBuild build) async { |
| if (build.variant.arch != 'arm64') { |
| return null; |
| } |
| |
| final flutterSo = await symbols.getEngineBinary(build); |
| |
| int? startAddr, endAddr; |
| final isCallAt = <bool>[]; |
| await for (var line in ndk.objdump(object: flutterSo, arch: 'arm64')) { |
| final m = _objdumpPattern.firstMatch(line); |
| if (m == null) continue; |
| |
| final addr = int.parse(m.namedGroup('addr')!, radix: 16); |
| startAddr ??= addr; |
| endAddr = addr; |
| final op = m.namedGroup('op')!; |
| isCallAt.add(op.startsWith('bl')); |
| } |
| if (startAddr == null || endAddr == null) { |
| return null; |
| } |
| final codeSize = endAddr - startAddr + 4; |
| if (codeSize != isCallAt.length * 4) { |
| // Something went wrong. |
| return null; |
| } |
| |
| return _CallLocations(startAddr, isCallAt); |
| } |
| |
| /// Try to guess load base for flutter engine shared object using |
| /// information about possible call locations in the binary and the |
| /// list of return addresses in the backtrace. |
| /// |
| /// We are going to look through the binary trying to find call locations |
| /// which have the same relative offsets to each other as the given pcs. |
| /// Each such group gives us potential load base. |
| Future<_LoadBase?> _tryFindLoadBase( |
| EngineBuild build, List<int> retAddrs) async { |
| _log.info('looking for load base of $build based on $retAddrs'); |
| if (retAddrs.length < 2) { |
| return null; // Need at least two retAddrs. |
| } |
| |
| // We don't expect any misaligned retAddrs, but some Crashlytics reports |
| // contain such. Give up for now. |
| if (retAddrs.any((e) => e & 3 != 0)) { |
| return null; |
| } |
| |
| final calls = await _determineCallLocations(build); |
| if (calls == null) { |
| return null; |
| } |
| |
| var loadBase = _tryFindLoadBaseImpl(build, retAddrs, calls); |
| if (loadBase != null) { |
| return _LoadBase(loadBase: loadBase, pcAdjusted: false); |
| } |
| |
| // Maybe unwinder already adjusted return addressed by -4. |
| loadBase = _tryFindLoadBaseImpl( |
| build, retAddrs.map((pc) => pc + 4).toList(), calls); |
| if (loadBase != null) { |
| return _LoadBase(loadBase: loadBase, pcAdjusted: true); |
| } |
| |
| return null; |
| } |
| |
| int? _tryFindLoadBaseImpl( |
| EngineBuild build, List<int> retAddrs, _CallLocations calls) { |
| const arm64InstrSize = 4; |
| const arm64InstrShift = 2; |
| const pageSize = 0x1000; |
| const pageMask = pageSize - 1; |
| |
| final retAddr = retAddrs.first; |
| final possibleBases = <int>[]; |
| |
| // Look through the binary for all calls such that pc - callAddr (which can be |
| // computed as `calls.startAddr + callIdx * arm64InstrSize`) is page aligned |
| // (this difference yields us possible base). |
| // We start by selecting base in such a way that the retAddr falls on the |
| // first page of the .text section and then start moving base down in |
| // pageSize increments. |
| final callVma = retAddr - arm64InstrSize - calls.startAddr; |
| for (var callIdx = (callVma & pageMask) >> arm64InstrShift, |
| base = callVma & ~pageMask; |
| callIdx < calls.size && base >= 0; |
| callIdx += pageSize >> arm64InstrShift, base -= pageSize) { |
| if (calls._isCallAt[callIdx]) { |
| if (retAddrs |
| .every((pc) => calls.isCallAt(pc - arm64InstrSize - base))) { |
| // Possible base: pc - arm64InstrSize - base hits call in the |
| // binary for all retAddrs. |
| possibleBases.add(base); |
| } |
| } |
| } |
| |
| // Single possible base found - return it. |
| if (possibleBases.length == 1) { |
| _log.info('found load base of $build based on $retAddrs: ' |
| '${possibleBases.first}'); |
| return possibleBases.first; |
| } |
| |
| // Either no bases or more than a single possibility found. |
| _log.info( |
| 'found ${possibleBases.isEmpty ? 'no' : 'multiple'} potential load ' |
| 'bases of $build based on $retAddrs: $possibleBases'); |
| return null; |
| } |
| |
| Future<CrashSymbolizationResult> _symbolizeIosFrames( |
| CrashSymbolizationResult result, |
| List<IosCrashFrame> frames, |
| String? arch, |
| EngineBuild build, |
| String symbolsDir) async { |
| final object = |
| p.join(symbolsDir, 'Flutter.dSYM/Contents/Resources/DWARF/Flutter'); |
| |
| // Returns [true] if the given frame is a frame for Flutter |
| // engine binary which misses an offset. |
| bool isFrameMissingOffset(IosCrashFrame frame) { |
| return frame.offset == null && |
| frame.binary == 'Flutter' && |
| frame.symbol == CrashFrame.crashalyticsMissingSymbol; |
| } |
| |
| var adjustInnerPCs = true; |
| |
| // If there are frames with missing offsets found try to guess |
| // load base using a heuristic based on all return addresses from the |
| // backtrace. |
| final framesWithoutOffsets = frames.where(isFrameMissingOffset).toList(); |
| if (framesWithoutOffsets.isNotEmpty) { |
| final loadBase = await _tryFindLoadBase( |
| build, |
| framesWithoutOffsets |
| .where((frame) => int.parse(frame.no) > 0) |
| .map((frame) => frame.pc) |
| .toSet() |
| .toList()); |
| if (loadBase != null) { |
| // Success: managed to find a single possiblity. Compute relative pcs |
| // using this loadBase and add a note to the symbolization result. |
| adjustInnerPCs = !loadBase.pcAdjusted; |
| result = result.withNote(SymbolizationNoteKind.loadBaseDetected, |
| _addrHex(loadBase.loadBase, _pointerSize(build.variant.arch))); |
| frames = frames.map((frame) { |
| if (isFrameMissingOffset(frame)) { |
| return frame.copyWith( |
| offset: frame.pc - loadBase.loadBase, |
| symbol: 'Flutter', |
| ); |
| } |
| return frame; |
| }).toList(); |
| } |
| } |
| |
| return _symbolizeGeneric<IosCrashFrame>( |
| result: result, |
| frames: frames, |
| arch: arch, |
| object: object, |
| shouldSymbolize: (frame) => |
| frame.symbol == 'Flutter' || frame.symbol.startsWith('0x'), |
| shouldAdjustInnerPCs: adjustInnerPCs, |
| getRelativePC: (frame) => frame.offset!, |
| computePCBias: (frames) => 0, |
| frameSuffix: (frame) => [ |
| '', |
| frame.symbol, |
| if (frame.offset != null) '+', |
| if (frame.offset != null) frame.offset, |
| if (frame.location.isNotEmpty) '(${frame.location.trimLeft()})', |
| ].join(' '), |
| ); |
| } |
| |
| Future<CrashSymbolizationResult> _symbolizeCustomFrames( |
| CrashSymbolizationResult result, |
| List<CustomCrashFrame> frames, |
| String? arch, |
| EngineBuild build, |
| String symbolsDir) async { |
| // For now we assuem |
| final object = p.join( |
| symbolsDir, |
| build.variant.os == 'ios' |
| ? 'Flutter.dSYM/Contents/Resources/DWARF/Flutter' |
| : 'libflutter.so'); |
| |
| // Returns [true] if the given frame is a frame for Flutter |
| // engine binary which misses an offset. |
| bool isFrameMissingOffset(CustomCrashFrame frame) { |
| return /*frame.offset == null &&*/ frame.binary == 'Flutter'; |
| } |
| |
| var adjustInnerPCs = true; |
| |
| // If there are frames with missing offsets found try to guess |
| // load base using a heuristic based on all return addresses from the |
| // backtrace. |
| final framesWithoutOffsets = frames.where(isFrameMissingOffset).toList(); |
| if (framesWithoutOffsets.isNotEmpty) { |
| final loadBase = await _tryFindLoadBase( |
| build, |
| framesWithoutOffsets |
| .where((frame) => int.parse(frame.no) > 0) |
| .map((frame) => frame.pc) |
| .toSet() |
| .toList()); |
| if (loadBase != null) { |
| // Success: managed to find a single possiblity. Compute relative pcs |
| // using this loadBase and add a note to the symbolization result. |
| adjustInnerPCs = !loadBase.pcAdjusted; |
| result = result.withNote(SymbolizationNoteKind.loadBaseDetected, |
| _addrHex(loadBase.loadBase, _pointerSize(build.variant.arch))); |
| frames = frames.map((frame) { |
| if (isFrameMissingOffset(frame)) { |
| return frame.copyWith( |
| offset: frame.pc - loadBase.loadBase, |
| symbol: 'Flutter', |
| ); |
| } |
| return frame; |
| }).toList(); |
| } |
| } |
| |
| return _symbolizeGeneric<CustomCrashFrame>( |
| result: result, |
| frames: frames, |
| arch: arch, |
| object: object, |
| shouldSymbolize: (frame) => true, |
| shouldAdjustInnerPCs: adjustInnerPCs, |
| getRelativePC: (frame) => frame.offset!, |
| computePCBias: (frames) => 0, |
| frameSuffix: (frame) => [ |
| '', |
| if (frame.symbol != null && frame.symbol!.isNotEmpty) |
| frame.symbol |
| else |
| frame.binary, |
| if (frame.offset != null) '+', |
| if (frame.offset != null) frame.offset, |
| if (frame.location != null) frame.location!.trimLeft(), |
| ].join(' '), |
| ); |
| } |
| } |
| |
| final _appBinaryPattern = RegExp(r'^/data/app/(~~[^/]+/)?[^/]+/(?<name>.*)$'); |
| String _shortBinaryName(String binary) { |
| final m = _appBinaryPattern.firstMatch(binary); |
| if (m != null) { |
| return '<...>/${m.namedGroup('name')}'; |
| } |
| return binary; |
| } |
| |
| int _pointerSize(String? arch) { |
| switch (arch) { |
| case 'arm64': |
| case 'x64': |
| return 8 * 2; |
| default: |
| return 4 * 2; |
| } |
| } |
| |
| String _addrHex(int v, int pointerSize) => |
| v.toRadixString(16).padLeft(pointerSize, '0'); |
| |
| String _asHex(int v) => '0x${v.toRadixString(16)}'; |
| |
| List<CrashSymbolizationResult> _failedToSymbolizeAll( |
| List<Crash> crashes, SymbolizationNoteKind note, {Object? error}) => |
| crashes |
| .map((crash) => _failedToSymbolize(crash, note, error: error)) |
| .toList(); |
| |
| CrashSymbolizationResult _failedToSymbolize( |
| Crash crash, SymbolizationNoteKind note, |
| {Object? error}) => |
| CrashSymbolizationResult( |
| crash: crash, |
| engineBuild: null, |
| symbolized: null, |
| notes: [SymbolizationNote(kind: note, message: error?.toString())], |
| ); |
| |
| final _reEngineHash = |
| RegExp(r'(• Engine|Engine •) revision (?<shortHash>[a-f0-9]+)'); |
| final _reFlutterVersion = RegExp( |
| r'Flutter \(Channel (?<channel>master|dev|beta|stable), (?<version>[^,]+),'); |
| |
| /// Information about call locations within the flutter engine binary. |
| /// Used to heuristically guess load base for flutter engine when it is |
| /// not available in the output. |
| /// |
| /// Currently heuristics only work on ARM64, which allows us to assume |
| /// fixed instruction size (4 bytes). |
| class _CallLocations { |
| /// Base VMA for the .text section. |
| final int startAddr; |
| |
| /// Contains [true] if instruction with the given index is a branch-link (bl). |
| final List<bool> _isCallAt; |
| |
| _CallLocations(this.startAddr, this._isCallAt); |
| |
| int get size => _isCallAt.length; |
| |
| bool isCallAt(int addr) { |
| if (addr < startAddr) return false; |
| final i = (addr - startAddr) >> 2; |
| return i < size && _isCallAt[i]; |
| } |
| } |
| |
| class _LoadBase { |
| final int loadBase; |
| final bool pcAdjusted; |
| _LoadBase({required this.loadBase, required this.pcAdjusted}); |
| } |
