runtime/tests/vm/dart/use_dwarf_stack_traces_flag_test.dart - sdk - 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.

 // This test ensures that the flag for --dwarf-stack-traces given at AOT
 // compile-time will be used at runtime (irrespective if other values were
 // passed to the runtime).

 // OtherResources=use_dwarf_stack_traces_flag_program.dart

 import "dart:async";
 import "dart:io";

 import 'package:expect/expect.dart';
 import 'package:native_stack_traces/native_stack_traces.dart';
 import 'package:path/path.dart' as path;

 import 'use_flag_test_helper.dart';

 main(List<String> args) async {
   if (!isAOTRuntime) {
     return; // Running in JIT: AOT binaries not available.
   }

   if (Platform.isAndroid) {
     return; // SDK tree and dart_bootstrap not available on the test device.
   }

   // These are the tools we need to be available to run on a given platform:
   if (!await testExecutable(genSnapshot)) {
     throw "Cannot run test as $genSnapshot not available";
   }
   if (!await testExecutable(aotRuntime)) {
     throw "Cannot run test as $aotRuntime not available";
   }
   if (!File(platformDill).existsSync()) {
     throw "Cannot run test as $platformDill does not exist";
   }

   await withTempDir('dwarf-flag-test', (String tempDir) async {
     final cwDir = path.dirname(Platform.script.toFilePath());
     final script = path.join(cwDir, 'use_dwarf_stack_traces_flag_program.dart');
     final scriptDill = path.join(tempDir, 'flag_program.dill');

     // Compile script to Kernel IR.
     await run(genKernel, <String>[
       '--aot',
       '--platform=$platformDill',
       '-o',
       scriptDill,
       script,
     ]);

     // Run the AOT compiler with/without Dwarf stack traces.
     final scriptDwarfSnapshot = path.join(tempDir, 'dwarf.so');
     final scriptNonDwarfSnapshot = path.join(tempDir, 'non_dwarf.so');
     final scriptDwarfDebugInfo = path.join(tempDir, 'debug_info.so');
     await Future.wait(<Future>[
       run(genSnapshot, <String>[
         // We test --dwarf-stack-traces-mode, not --dwarf-stack-traces, because
         // the latter is a handler that sets the former and also may change
         // other flags. This way, we limit the difference between the two
         // snapshots and also directly test the flag saved as a VM global flag.
         '--dwarf-stack-traces-mode',
         '--save-debugging-info=$scriptDwarfDebugInfo',
         '--snapshot-kind=app-aot-elf',
         '--elf=$scriptDwarfSnapshot',
         scriptDill,
       ]),
       run(genSnapshot, <String>[
         '--no-dwarf-stack-traces-mode',
         '--snapshot-kind=app-aot-elf',
         '--elf=$scriptNonDwarfSnapshot',
         scriptDill,
       ]),
     ]);

     // Run the resulting Dwarf-AOT compiled script.
     final dwarfTrace1 = await runError(aotRuntime, <String>[
       '--dwarf-stack-traces-mode',
       scriptDwarfSnapshot,
       scriptDill,
     ]);
     final dwarfTrace2 = await runError(aotRuntime, <String>[
       '--no-dwarf-stack-traces-mode',
       scriptDwarfSnapshot,
       scriptDill,
     ]);

     // Run the resulting non-Dwarf-AOT compiled script.
     final nonDwarfTrace1 = await runError(aotRuntime, <String>[
       '--dwarf-stack-traces-mode',
       scriptNonDwarfSnapshot,
       scriptDill,
     ]);
     final nonDwarfTrace2 = await runError(aotRuntime, <String>[
       '--no-dwarf-stack-traces-mode',
       scriptNonDwarfSnapshot,
       scriptDill,
     ]);

     // Ensure the result is based off the flag passed to gen_snapshot, not
     // the one passed to the runtime.
     Expect.deepEquals(nonDwarfTrace1, nonDwarfTrace2);

     // For DWARF stack traces, we can't guarantee that the stack traces are
     // textually equal on all platforms, but if we retrieve the PC offsets
     // out of the stack trace, those should be equal.
     final tracePCOffsets1 = collectPCOffsets(dwarfTrace1);
     final tracePCOffsets2 = collectPCOffsets(dwarfTrace2);
     Expect.deepEquals(tracePCOffsets1, tracePCOffsets2);

     // Check that translating the DWARF stack trace (without internal frames)
     // matches the symbolic stack trace.
     final dwarf = Dwarf.fromFile(scriptDwarfDebugInfo)!;

     // Check that build IDs match for traces.
     Expect.isNotNull(dwarf.buildId);
     print('Dwarf build ID: "${dwarf.buildId!}"');
     // We should never generate an all-zero build ID.
     Expect.notEquals(dwarf.buildId, "00000000000000000000000000000000");
     // This is a common failure case as well, when HashBitsContainer ends up
     // hashing over seemingly empty sections.
     Expect.notEquals(dwarf.buildId, "01000000010000000100000001000000");
     final buildId1 = buildId(dwarfTrace1);
     Expect.isFalse(buildId1.isEmpty);
     print('Trace 1 build ID: "${buildId1}"');
     Expect.equals(dwarf.buildId, buildId1);
     final buildId2 = buildId(dwarfTrace2);
     Expect.isFalse(buildId2.isEmpty);
     print('Trace 2 build ID: "${buildId2}"');
     Expect.equals(dwarf.buildId, buildId2);

     final translatedDwarfTrace1 = await Stream.fromIterable(dwarfTrace1)
         .transform(DwarfStackTraceDecoder(dwarf))
         .toList();

     final translatedStackFrames = onlySymbolicFrameLines(translatedDwarfTrace1);
     final originalStackFrames = onlySymbolicFrameLines(nonDwarfTrace1);

     print('Stack frames from translated non-symbolic stack trace:');
     translatedStackFrames.forEach(print);
     print('');

     print('Stack frames from original symbolic stack trace:');
     originalStackFrames.forEach(print);
     print('');

     Expect.isTrue(translatedStackFrames.length > 0);
     Expect.isTrue(originalStackFrames.length > 0);

     // In symbolic mode, we don't store column information to avoid an increase
     // in size of CodeStackMaps. Thus, we need to strip any columns from the
     // translated non-symbolic stack to compare them via equality.
     final columnStrippedTranslated = removeColumns(translatedStackFrames);

     print('Stack frames from translated non-symbolic stack trace, no columns:');
     columnStrippedTranslated.forEach(print);
     print('');

     Expect.deepEquals(columnStrippedTranslated, originalStackFrames);

     // Since we compiled directly to ELF, there should be a DSO base address
     // in the stack trace header and 'virt' markers in the stack frames.

     // The offsets of absolute addresses from their respective DSO base
     // should be the same for both traces.
     final dsoBase1 = dsoBaseAddresses(dwarfTrace1).single;
     final dsoBase2 = dsoBaseAddresses(dwarfTrace2).single;

     final absTrace1 = absoluteAddresses(dwarfTrace1);
     final absTrace2 = absoluteAddresses(dwarfTrace2);

     final relocatedFromDso1 = absTrace1.map((a) => a - dsoBase1);
     final relocatedFromDso2 = absTrace2.map((a) => a - dsoBase2);

     Expect.deepEquals(relocatedFromDso1, relocatedFromDso2);

     // The relocated addresses marked with 'virt' should match between the
     // different runs, and they should also match the relocated address
     // calculated from the PCOffset for each frame as well as the relocated
     // address for each frame calculated using the respective DSO base.
     final virtTrace1 = explicitVirtualAddresses(dwarfTrace1);
     final virtTrace2 = explicitVirtualAddresses(dwarfTrace2);

     Expect.deepEquals(virtTrace1, virtTrace2);

     Expect.deepEquals(
         virtTrace1, tracePCOffsets1.map((o) => o.virtualAddressIn(dwarf)));
     Expect.deepEquals(
         virtTrace2, tracePCOffsets2.map((o) => o.virtualAddressIn(dwarf)));

     Expect.deepEquals(virtTrace1, relocatedFromDso1);
     Expect.deepEquals(virtTrace2, relocatedFromDso2);
   });
 }

 final _buildIdRE = RegExp(r"build_id: '([a-f\d]+)'");
 String buildId(Iterable<String> lines) {
   for (final line in lines) {
     final match = _buildIdRE.firstMatch(line);
     if (match != null) {
       return match.group(1)!;
     }
   }
   return '';
 }

 final _symbolicFrameRE = RegExp(r'^#\d+\s+');

 Iterable<String> onlySymbolicFrameLines(Iterable<String> lines) {
   return lines.where((line) => _symbolicFrameRE.hasMatch(line));
 }

 final _columnsRE = RegExp(r'[(](.*:\d+):\d+[)]');

 Iterable<String> removeColumns(Iterable<String> lines) sync* {
   for (final line in lines) {
     final match = _columnsRE.firstMatch(line);
     if (match != null) {
       yield line.replaceRange(match.start, match.end, '(${match.group(1)!})');
     } else {
       yield line;
     }
   }
 }

 Iterable<int> parseUsingAddressRegExp(RegExp re, Iterable<String> lines) sync* {
   for (final line in lines) {
     final match = re.firstMatch(line);
     if (match != null) {
       yield int.parse(match.group(1)!, radix: 16);
     }
   }
 }

 final _absRE = RegExp(r'abs ([a-f\d]+)');

 Iterable<int> absoluteAddresses(Iterable<String> lines) =>
     parseUsingAddressRegExp(_absRE, lines);

 final _virtRE = RegExp(r'virt ([a-f\d]+)');

 Iterable<int> explicitVirtualAddresses(Iterable<String> lines) =>
     parseUsingAddressRegExp(_virtRE, lines);

 final _dsoBaseRE = RegExp(r'isolate_dso_base: ([a-f\d]+)');

 Iterable<int> dsoBaseAddresses(Iterable<String> lines) =>
     parseUsingAddressRegExp(_dsoBaseRE, lines);
	// 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.

	// This test ensures that the flag for --dwarf-stack-traces given at AOT
	// compile-time will be used at runtime (irrespective if other values were
	// passed to the runtime).

	// OtherResources=use_dwarf_stack_traces_flag_program.dart

	import "dart:async";
	import "dart:io";

	import 'package:expect/expect.dart';
	import 'package:native_stack_traces/native_stack_traces.dart';
	import 'package:path/path.dart' as path;

	import 'use_flag_test_helper.dart';

	main(List<String> args) async {
	if (!isAOTRuntime) {
	return; // Running in JIT: AOT binaries not available.
	}

	if (Platform.isAndroid) {
	return; // SDK tree and dart_bootstrap not available on the test device.
	}

	// These are the tools we need to be available to run on a given platform:
	if (!await testExecutable(genSnapshot)) {
	throw "Cannot run test as $genSnapshot not available";
	}
	if (!await testExecutable(aotRuntime)) {
	throw "Cannot run test as $aotRuntime not available";
	}
	if (!File(platformDill).existsSync()) {
	throw "Cannot run test as $platformDill does not exist";
	}

	await withTempDir('dwarf-flag-test', (String tempDir) async {
	final cwDir = path.dirname(Platform.script.toFilePath());
	final script = path.join(cwDir, 'use_dwarf_stack_traces_flag_program.dart');
	final scriptDill = path.join(tempDir, 'flag_program.dill');

	// Compile script to Kernel IR.
	await run(genKernel, <String>[
	'--aot',
	'--platform=$platformDill',
	'-o',
	scriptDill,
	script,
	]);

	// Run the AOT compiler with/without Dwarf stack traces.
	final scriptDwarfSnapshot = path.join(tempDir, 'dwarf.so');
	final scriptNonDwarfSnapshot = path.join(tempDir, 'non_dwarf.so');
	final scriptDwarfDebugInfo = path.join(tempDir, 'debug_info.so');
	await Future.wait(<Future>[
	run(genSnapshot, <String>[
	// We test --dwarf-stack-traces-mode, not --dwarf-stack-traces, because
	// the latter is a handler that sets the former and also may change
	// other flags. This way, we limit the difference between the two
	// snapshots and also directly test the flag saved as a VM global flag.
	'--dwarf-stack-traces-mode',
	'--save-debugging-info=$scriptDwarfDebugInfo',
	'--snapshot-kind=app-aot-elf',
	'--elf=$scriptDwarfSnapshot',
	scriptDill,
	]),
	run(genSnapshot, <String>[
	'--no-dwarf-stack-traces-mode',
	'--snapshot-kind=app-aot-elf',
	'--elf=$scriptNonDwarfSnapshot',
	scriptDill,
	]),
	]);

	// Run the resulting Dwarf-AOT compiled script.
	final dwarfTrace1 = await runError(aotRuntime, <String>[
	'--dwarf-stack-traces-mode',
	scriptDwarfSnapshot,
	scriptDill,
	]);
	final dwarfTrace2 = await runError(aotRuntime, <String>[
	'--no-dwarf-stack-traces-mode',
	scriptDwarfSnapshot,
	scriptDill,
	]);

	// Run the resulting non-Dwarf-AOT compiled script.
	final nonDwarfTrace1 = await runError(aotRuntime, <String>[
	'--dwarf-stack-traces-mode',
	scriptNonDwarfSnapshot,
	scriptDill,
	]);
	final nonDwarfTrace2 = await runError(aotRuntime, <String>[
	'--no-dwarf-stack-traces-mode',
	scriptNonDwarfSnapshot,
	scriptDill,
	]);

	// Ensure the result is based off the flag passed to gen_snapshot, not
	// the one passed to the runtime.
	Expect.deepEquals(nonDwarfTrace1, nonDwarfTrace2);

	// For DWARF stack traces, we can't guarantee that the stack traces are
	// textually equal on all platforms, but if we retrieve the PC offsets
	// out of the stack trace, those should be equal.
	final tracePCOffsets1 = collectPCOffsets(dwarfTrace1);
	final tracePCOffsets2 = collectPCOffsets(dwarfTrace2);
	Expect.deepEquals(tracePCOffsets1, tracePCOffsets2);

	// Check that translating the DWARF stack trace (without internal frames)
	// matches the symbolic stack trace.
	final dwarf = Dwarf.fromFile(scriptDwarfDebugInfo)!;

	// Check that build IDs match for traces.
	Expect.isNotNull(dwarf.buildId);
	print('Dwarf build ID: "${dwarf.buildId!}"');
	// We should never generate an all-zero build ID.
	Expect.notEquals(dwarf.buildId, "00000000000000000000000000000000");
	// This is a common failure case as well, when HashBitsContainer ends up
	// hashing over seemingly empty sections.
	Expect.notEquals(dwarf.buildId, "01000000010000000100000001000000");
	final buildId1 = buildId(dwarfTrace1);
	Expect.isFalse(buildId1.isEmpty);
	print('Trace 1 build ID: "${buildId1}"');
	Expect.equals(dwarf.buildId, buildId1);
	final buildId2 = buildId(dwarfTrace2);
	Expect.isFalse(buildId2.isEmpty);
	print('Trace 2 build ID: "${buildId2}"');
	Expect.equals(dwarf.buildId, buildId2);

	final translatedDwarfTrace1 = await Stream.fromIterable(dwarfTrace1)
	.transform(DwarfStackTraceDecoder(dwarf))
	.toList();

	final translatedStackFrames = onlySymbolicFrameLines(translatedDwarfTrace1);
	final originalStackFrames = onlySymbolicFrameLines(nonDwarfTrace1);

	print('Stack frames from translated non-symbolic stack trace:');
	translatedStackFrames.forEach(print);
	print('');

	print('Stack frames from original symbolic stack trace:');
	originalStackFrames.forEach(print);
	print('');

	Expect.isTrue(translatedStackFrames.length > 0);
	Expect.isTrue(originalStackFrames.length > 0);

	// In symbolic mode, we don't store column information to avoid an increase
	// in size of CodeStackMaps. Thus, we need to strip any columns from the
	// translated non-symbolic stack to compare them via equality.
	final columnStrippedTranslated = removeColumns(translatedStackFrames);

	print('Stack frames from translated non-symbolic stack trace, no columns:');
	columnStrippedTranslated.forEach(print);
	print('');

	Expect.deepEquals(columnStrippedTranslated, originalStackFrames);

	// Since we compiled directly to ELF, there should be a DSO base address
	// in the stack trace header and 'virt' markers in the stack frames.

	// The offsets of absolute addresses from their respective DSO base
	// should be the same for both traces.
	final dsoBase1 = dsoBaseAddresses(dwarfTrace1).single;
	final dsoBase2 = dsoBaseAddresses(dwarfTrace2).single;

	final absTrace1 = absoluteAddresses(dwarfTrace1);
	final absTrace2 = absoluteAddresses(dwarfTrace2);

	final relocatedFromDso1 = absTrace1.map((a) => a - dsoBase1);
	final relocatedFromDso2 = absTrace2.map((a) => a - dsoBase2);

	Expect.deepEquals(relocatedFromDso1, relocatedFromDso2);

	// The relocated addresses marked with 'virt' should match between the
	// different runs, and they should also match the relocated address
	// calculated from the PCOffset for each frame as well as the relocated
	// address for each frame calculated using the respective DSO base.
	final virtTrace1 = explicitVirtualAddresses(dwarfTrace1);
	final virtTrace2 = explicitVirtualAddresses(dwarfTrace2);

	Expect.deepEquals(virtTrace1, virtTrace2);

	Expect.deepEquals(
	virtTrace1, tracePCOffsets1.map((o) => o.virtualAddressIn(dwarf)));
	Expect.deepEquals(
	virtTrace2, tracePCOffsets2.map((o) => o.virtualAddressIn(dwarf)));

	Expect.deepEquals(virtTrace1, relocatedFromDso1);
	Expect.deepEquals(virtTrace2, relocatedFromDso2);
	});
	}

	final _buildIdRE = RegExp(r"build_id: '([a-f\d]+)'");
	String buildId(Iterable<String> lines) {
	for (final line in lines) {
	final match = _buildIdRE.firstMatch(line);
	if (match != null) {
	return match.group(1)!;
	}
	}
	return '';
	}

	final _symbolicFrameRE = RegExp(r'^#\d+\s+');

	Iterable<String> onlySymbolicFrameLines(Iterable<String> lines) {
	return lines.where((line) => _symbolicFrameRE.hasMatch(line));
	}

	final _columnsRE = RegExp(r'[(](.*:\d+):\d+[)]');

	Iterable<String> removeColumns(Iterable<String> lines) sync* {
	for (final line in lines) {
	final match = _columnsRE.firstMatch(line);
	if (match != null) {
	yield line.replaceRange(match.start, match.end, '(${match.group(1)!})');
	} else {
	yield line;
	}
	}
	}

	Iterable<int> parseUsingAddressRegExp(RegExp re, Iterable<String> lines) sync* {
	for (final line in lines) {
	final match = re.firstMatch(line);
	if (match != null) {
	yield int.parse(match.group(1)!, radix: 16);
	}
	}
	}

	final _absRE = RegExp(r'abs ([a-f\d]+)');

	Iterable<int> absoluteAddresses(Iterable<String> lines) =>
	parseUsingAddressRegExp(_absRE, lines);

	final _virtRE = RegExp(r'virt ([a-f\d]+)');

	Iterable<int> explicitVirtualAddresses(Iterable<String> lines) =>
	parseUsingAddressRegExp(_virtRE, lines);

	final _dsoBaseRE = RegExp(r'isolate_dso_base: ([a-f\d]+)');

	Iterable<int> dsoBaseAddresses(Iterable<String> lines) =>
	parseUsingAddressRegExp(_dsoBaseRE, lines);