mirror of
https://github.com/dart-lang/sdk
synced 2024-10-14 07:19:58 +00:00
a4aaaf05eb
Cq-Include-Trybots: luci.dart.try:vm-kernel-precomp-linux-release-x64-try,vm-kernel-precomp-mac-release-simarm64-try,vm-kernel-precomp-win-release-x64-try Change-Id: I285aada8ee46b2caf212957dfc400f00d4aa25b5 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/133066 Commit-Queue: Teagan Strickland <sstrickl@google.com> Reviewed-by: Lasse R.H. Nielsen <lrn@google.com>
236 lines
7.8 KiB
Dart
236 lines
7.8 KiB
Dart
// Copyright (c) 2017, 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.
|
|
|
|
/// VMOptions=--dwarf-stack-traces --save-debugging-info=dwarf.so
|
|
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
|
|
import 'package:native_stack_traces/native_stack_traces.dart';
|
|
import 'package:path/path.dart' as path;
|
|
import 'package:unittest/unittest.dart';
|
|
|
|
@pragma("vm:prefer-inline")
|
|
bar() {
|
|
// Keep the 'throw' and its argument on separate lines.
|
|
throw // force linebreak with dartfmt
|
|
"Hello, Dwarf!";
|
|
}
|
|
|
|
@pragma("vm:never-inline")
|
|
foo() {
|
|
bar();
|
|
}
|
|
|
|
Future<void> main() async {
|
|
String rawStack;
|
|
try {
|
|
foo();
|
|
} catch (e, st) {
|
|
rawStack = st.toString();
|
|
}
|
|
|
|
if (path.basenameWithoutExtension(Platform.executable) !=
|
|
"dart_precompiled_runtime") {
|
|
return; // Not running from an AOT compiled snapshot.
|
|
}
|
|
|
|
if (Platform.isAndroid) {
|
|
return; // Generated dwarf.so not available on the test device.
|
|
}
|
|
|
|
final dwarf = Dwarf.fromFile("dwarf.so");
|
|
|
|
await checkStackTrace(rawStack, dwarf, expectedCallsInfo);
|
|
}
|
|
|
|
Future<void> checkStackTrace(String rawStack, Dwarf dwarf,
|
|
List<List<CallInfo>> expectedCallsInfo) async {
|
|
final expectedAllCallsInfo = expectedCallsInfo;
|
|
final expectedExternalCallInfo = removeInternalCalls(expectedCallsInfo);
|
|
|
|
print("");
|
|
print("Raw stack trace:");
|
|
print(rawStack);
|
|
|
|
final rawLines =
|
|
await Stream.value(rawStack).transform(const LineSplitter()).toList();
|
|
|
|
final pcOffsets = collectPCOffsets(rawLines).toList();
|
|
|
|
// We should have at least enough PC addresses to cover the frames we'll be
|
|
// checking.
|
|
expect(pcOffsets.length, greaterThanOrEqualTo(expectedAllCallsInfo.length));
|
|
|
|
final virtualAddresses =
|
|
pcOffsets.map((o) => dwarf.virtualAddressOf(o)).toList();
|
|
|
|
final externalFramesInfo = <List<CallInfo>>[];
|
|
final allFramesInfo = <List<CallInfo>>[];
|
|
|
|
for (final addr in virtualAddresses) {
|
|
externalFramesInfo.add(dwarf.callInfoFor(addr)?.toList());
|
|
allFramesInfo
|
|
.add(dwarf.callInfoFor(addr, includeInternalFrames: true)?.toList());
|
|
}
|
|
|
|
print("");
|
|
print("Call information for PC addresses:");
|
|
for (var i = 0; i < virtualAddresses.length; i++) {
|
|
print("For PC 0x${virtualAddresses[i].toRadixString(16)}:");
|
|
print(" Calls corresponding to user or library code:");
|
|
externalFramesInfo[i]?.forEach((frame) => print(" ${frame}"));
|
|
print(" All calls:");
|
|
allFramesInfo[i]?.forEach((frame) => print(" ${frame}"));
|
|
}
|
|
|
|
// Check that our results are also consistent.
|
|
checkConsistency(externalFramesInfo, allFramesInfo);
|
|
|
|
checkFrames(externalFramesInfo, expectedExternalCallInfo);
|
|
checkFrames(allFramesInfo, expectedAllCallsInfo);
|
|
|
|
final externalSymbolizedLines = await Stream.fromIterable(rawLines)
|
|
.transform(DwarfStackTraceDecoder(dwarf))
|
|
.toList();
|
|
|
|
final externalSymbolizedCalls =
|
|
externalSymbolizedLines.where((s) => s.startsWith('#')).toList();
|
|
|
|
print("");
|
|
print("Symbolized external-only stack trace:");
|
|
externalSymbolizedLines.forEach(print);
|
|
print("");
|
|
print("Extracted calls:");
|
|
externalSymbolizedCalls.forEach(print);
|
|
|
|
final allSymbolizedLines = await Stream.fromIterable(rawLines)
|
|
.transform(DwarfStackTraceDecoder(dwarf, includeInternalFrames: true))
|
|
.toList();
|
|
|
|
final allSymbolizedCalls =
|
|
allSymbolizedLines.where((s) => s.startsWith('#')).toList();
|
|
|
|
print("");
|
|
print("Symbolized full stack trace:");
|
|
allSymbolizedLines.forEach(print);
|
|
print("");
|
|
print("Extracted calls:");
|
|
allSymbolizedCalls.forEach(print);
|
|
|
|
final expectedExternalStrings = extractCallStrings(expectedExternalCallInfo);
|
|
// There are two strings in the list for each line in the output.
|
|
final expectedExternalCallCount = expectedExternalStrings.length ~/ 2;
|
|
final expectedStrings = extractCallStrings(expectedAllCallsInfo);
|
|
final expectedCallCount = expectedStrings.length ~/ 2;
|
|
|
|
expect(externalSymbolizedCalls.length,
|
|
greaterThanOrEqualTo(expectedExternalCallCount));
|
|
expect(allSymbolizedCalls.length, greaterThanOrEqualTo(expectedCallCount));
|
|
|
|
// Strip off any unexpected lines, so we can also make sure we didn't get
|
|
// unexpected calls prior to those calls we expect.
|
|
final externalCallsTrace =
|
|
externalSymbolizedCalls.sublist(0, expectedExternalCallCount).join('\n');
|
|
final allCallsTrace =
|
|
allSymbolizedCalls.sublist(0, expectedCallCount).join('\n');
|
|
|
|
expect(externalCallsTrace, stringContainsInOrder(expectedExternalStrings));
|
|
expect(allCallsTrace, stringContainsInOrder(expectedStrings));
|
|
}
|
|
|
|
final expectedCallsInfo = <List<CallInfo>>[
|
|
// The first frame should correspond to the throw in bar, which was inlined
|
|
// into foo (so we'll get information for two calls for that PC address).
|
|
[
|
|
CallInfo(
|
|
function: "bar",
|
|
filename: "dwarf_stack_trace_test.dart",
|
|
line: 17,
|
|
inlined: true),
|
|
CallInfo(
|
|
function: "foo",
|
|
filename: "dwarf_stack_trace_test.dart",
|
|
line: 23,
|
|
inlined: false)
|
|
],
|
|
// The second frame corresponds to call to foo in main.
|
|
[
|
|
CallInfo(
|
|
function: "main",
|
|
filename: "dwarf_stack_trace_test.dart",
|
|
line: 29,
|
|
inlined: false)
|
|
],
|
|
// Don't assume anything about any of the frames below the call to foo
|
|
// in main, as this makes the test too brittle.
|
|
];
|
|
|
|
List<List<CallInfo>> removeInternalCalls(List<List<CallInfo>> original) =>
|
|
original
|
|
.map((frame) => frame.where((call) => call.line > 0).toList())
|
|
.toList();
|
|
|
|
void checkConsistency(
|
|
List<List<CallInfo>> externalFrames, List<List<CallInfo>> allFrames) {
|
|
// We should have the same number of frames for both external-only
|
|
// and combined call information.
|
|
expect(externalFrames.length, equals(allFrames.length));
|
|
// There should be no frames in either version where we failed to look up
|
|
// call information.
|
|
expect(externalFrames, everyElement(isNotNull));
|
|
expect(allFrames, everyElement(isNotNull));
|
|
// All frames in the internal-including version should have at least one
|
|
// piece of call information.
|
|
expect(allFrames, everyElement(isNotEmpty));
|
|
// External-only call information should only include call information with
|
|
// positive line numbers.
|
|
expect(
|
|
externalFrames, everyElement(everyElement(predicate((c) => c.line > 0))));
|
|
// The information in the external-only and combined call information should
|
|
// be consistent for external frames.
|
|
for (var i = 0; i < allFrames.length; i++) {
|
|
expect(externalFrames[i], anyOf(isEmpty, equals(allFrames[i])));
|
|
}
|
|
}
|
|
|
|
void checkFrames(
|
|
List<List<CallInfo>> framesInfo, List<List<CallInfo>> expectedInfo) {
|
|
// There may be frames below those we check.
|
|
expect(framesInfo.length, greaterThanOrEqualTo(expectedInfo.length));
|
|
|
|
// We can't just use deep equality, since we only have the filenames in the
|
|
// expected version, not the whole path, and we don't really care if
|
|
// non-positive line numbers match, as long as they're both non-positive.
|
|
for (var i = 0; i < expectedInfo.length; i++) {
|
|
for (var j = 0; j < expectedInfo[i].length; j++) {
|
|
final got = framesInfo[i][j];
|
|
final expected = expectedInfo[i][j];
|
|
expect(got.function, equals(expected.function));
|
|
expect(got.inlined, equals(expected.inlined));
|
|
expect(path.basename(got.filename), equals(expected.filename));
|
|
if (expected.line > 0) {
|
|
expect(got.line, equals(expected.line));
|
|
} else {
|
|
expect(got.line, lessThanOrEqualTo(0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
List<String> extractCallStrings(List<List<CallInfo>> expectedCalls) {
|
|
var ret = <String>[];
|
|
for (final frame in expectedCalls) {
|
|
for (final call in frame) {
|
|
ret.add(call.function);
|
|
if (call.line > 0) {
|
|
ret.add("${call.filename}:${call.line}");
|
|
} else {
|
|
ret.add("${call.filename}:??");
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|