Version 2.14.0-30.0.dev
Merge commit '6616bb46967a616b39eb4cc457c133f53a4a8da2' into 'dev'
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/why_not_promoted/data/nullable_operator_call_error.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/why_not_promoted/data/nullable_operator_call_error.dart
new file mode 100644
index 0000000..c619de5
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/why_not_promoted/data/nullable_operator_call_error.dart
@@ -0,0 +1,32 @@
+// Copyright (c) 2021, 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 contains a test case for each condition that can lead to the front
+// end's `NullableOperatorCallError` error, for which we wish to report "why not
+// promoted" context information.
+
+class C1 {
+ int? bad;
+}
+
+userDefinableBinaryOpLhs(C1 c) {
+ if (c.bad == null) return;
+ c.bad
+ /*cfe.invoke: notPromoted(propertyNotPromoted(target: member:C1.bad, type: int?))*/
+ /*analyzer.notPromoted(propertyNotPromoted(target: member:C1.bad, type: int?))*/
+ +
+ 1;
+}
+
+class C2 {
+ int? bad;
+}
+
+userDefinableUnaryOp(C2 c) {
+ if (c.bad == null) return;
+ /*cfe.invoke: notPromoted(propertyNotPromoted(target: member:C2.bad, type: int?))*/
+ -c.
+ /*analyzer.notPromoted(propertyNotPromoted(target: member:C2.bad, type: int?))*/
+ bad;
+}
diff --git a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
index 20a67a7..69a9aa7 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -666,7 +666,8 @@
read,
readType,
node.binaryName,
- node.rhs);
+ node.rhs,
+ null);
Expression binary = binaryResult.expression;
DartType binaryType = binaryResult.inferredType;
@@ -2906,7 +2907,8 @@
read,
readType,
node.binaryName,
- node.rhs);
+ node.rhs,
+ null);
DartType binaryType = binaryResult.inferredType;
Expression binary =
@@ -3999,7 +4001,8 @@
Expression left,
DartType leftType,
Name binaryName,
- Expression right) {
+ Expression right,
+ Map<DartType, NonPromotionReason> Function() whyNotPromoted) {
assert(binaryName != equalsName);
ObjectAccessTarget binaryTarget = inferrer.findInterfaceMember(
@@ -4203,6 +4206,10 @@
}
if (!inferrer.isTopLevel && binaryTarget.isNullable) {
+ List<LocatedMessage> context = inferrer.getWhyNotPromotedContext(
+ whyNotPromoted?.call(),
+ binary,
+ (type) => !type.isPotentiallyNullable);
return new ExpressionInferenceResult(
binaryType,
inferrer.helper.wrapInProblem(
@@ -4210,7 +4217,8 @@
templateNullableOperatorCallError.withArguments(
binaryName.text, leftType, inferrer.isNonNullableByDefault),
binary.fileOffset,
- binaryName.text.length));
+ binaryName.text.length,
+ context: context));
}
return new ExpressionInferenceResult(binaryType, binary);
}
@@ -4220,8 +4228,12 @@
///
/// [fileOffset] is used as the file offset for created nodes.
/// [expressionType] is the already inferred type of the [expression].
- ExpressionInferenceResult _computeUnaryExpression(int fileOffset,
- Expression expression, DartType expressionType, Name unaryName) {
+ ExpressionInferenceResult _computeUnaryExpression(
+ int fileOffset,
+ Expression expression,
+ DartType expressionType,
+ Name unaryName,
+ Map<DartType, NonPromotionReason> Function() whyNotPromoted) {
ObjectAccessTarget unaryTarget = inferrer.findInterfaceMember(
expressionType, unaryName, fileOffset,
includeExtensionMethods: true);
@@ -4352,6 +4364,8 @@
}
if (!inferrer.isTopLevel && unaryTarget.isNullable) {
+ List<LocatedMessage> context = inferrer.getWhyNotPromotedContext(
+ whyNotPromoted?.call(), unary, (type) => !type.isPotentiallyNullable);
// TODO(johnniwinther): Special case 'unary-' in messages. It should
// probably be referred to as "Unary operator '-' ...".
return new ExpressionInferenceResult(
@@ -4361,7 +4375,8 @@
templateNullableOperatorCallError.withArguments(unaryName.text,
expressionType, inferrer.isNonNullableByDefault),
unary.fileOffset,
- unaryName == unaryMinusName ? 1 : unaryName.text.length));
+ unaryName == unaryMinusName ? 1 : unaryName.text.length,
+ context: context));
}
return new ExpressionInferenceResult(unaryType, unary);
}
@@ -5121,7 +5136,8 @@
left,
readType,
node.binaryName,
- node.rhs);
+ node.rhs,
+ null);
Expression binary = binaryResult.expression;
DartType binaryType = binaryResult.inferredType;
@@ -5263,7 +5279,8 @@
left,
readType,
node.binaryName,
- node.rhs);
+ node.rhs,
+ null);
Expression binary = binaryResult.expression;
DartType binaryType = binaryResult.inferredType;
@@ -5417,7 +5434,8 @@
left,
readType,
node.binaryName,
- node.rhs);
+ node.rhs,
+ null);
Expression binary = binaryResult.expression;
DartType binaryType = binaryResult.inferredType;
@@ -5596,7 +5614,8 @@
left,
readType,
node.binaryName,
- node.rhs);
+ node.rhs,
+ null);
Expression binary = binaryResult.expression;
DartType binaryType = binaryResult.inferredType;
@@ -6922,13 +6941,16 @@
BinaryExpression node, DartType typeContext) {
ExpressionInferenceResult leftResult =
inferrer.inferExpression(node.left, const UnknownType(), true);
+ Map<DartType, NonPromotionReason> Function() whyNotPromoted =
+ inferrer.flowAnalysis?.whyNotPromoted(leftResult.expression);
return _computeBinaryExpression(
node.fileOffset,
typeContext,
leftResult.expression,
leftResult.inferredType,
node.binaryName,
- node.right);
+ node.right,
+ whyNotPromoted);
}
ExpressionInferenceResult visitUnary(
@@ -7001,8 +7023,10 @@
expressionResult =
inferrer.inferExpression(node.expression, const UnknownType(), true);
}
+ Map<DartType, NonPromotionReason> Function() whyNotPromoted =
+ inferrer.flowAnalysis?.whyNotPromoted(expressionResult.expression);
return _computeUnaryExpression(node.fileOffset, expressionResult.expression,
- expressionResult.inferredType, node.unaryName);
+ expressionResult.inferredType, node.unaryName, whyNotPromoted);
}
ExpressionInferenceResult visitParenthesized(
diff --git a/pkg/native_stack_traces/CHANGELOG.md b/pkg/native_stack_traces/CHANGELOG.md
index 9b16d1c..4a9f873 100644
--- a/pkg/native_stack_traces/CHANGELOG.md
+++ b/pkg/native_stack_traces/CHANGELOG.md
@@ -1,5 +1,9 @@
# Changelog
+## 0.4.1
+
+- Exported some ELF utilities in lib/elf.dart for use in Dart tests.
+
## 0.4.0
- Stable null safe version of package.
diff --git a/pkg/native_stack_traces/lib/elf.dart b/pkg/native_stack_traces/lib/elf.dart
new file mode 100644
index 0000000..de32cd3
--- /dev/null
+++ b/pkg/native_stack_traces/lib/elf.dart
@@ -0,0 +1,11 @@
+// Copyright (c) 2021, 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.
+
+export 'src/elf.dart' show Elf, Symbol;
+export 'src/constants.dart'
+ show
+ isolateDataSymbolName,
+ isolateSymbolName,
+ vmDataSymbolName,
+ vmSymbolName;
diff --git a/pkg/native_stack_traces/lib/src/constants.dart b/pkg/native_stack_traces/lib/src/constants.dart
index c44d615..ca987f5 100644
--- a/pkg/native_stack_traces/lib/src/constants.dart
+++ b/pkg/native_stack_traces/lib/src/constants.dart
@@ -12,5 +12,11 @@
// The dynamic symbol name for the VM instructions section.
const String vmSymbolName = "_kDartVmSnapshotInstructions";
+// The dynamic symbol name for the VM data section.
+const String vmDataSymbolName = "_kDartVmSnapshotData";
+
// The dynamic symbol name for the isolate instructions section.
const String isolateSymbolName = "_kDartIsolateSnapshotInstructions";
+
+// The dynamic symbol name for the isolate data section.
+const String isolateDataSymbolName = "_kDartIsolateSnapshotData";
diff --git a/pkg/native_stack_traces/pubspec.yaml b/pkg/native_stack_traces/pubspec.yaml
index df71c5a..f93e01b 100644
--- a/pkg/native_stack_traces/pubspec.yaml
+++ b/pkg/native_stack_traces/pubspec.yaml
@@ -1,6 +1,6 @@
name: native_stack_traces
description: Utilities for working with non-symbolic stack traces.
-version: 0.4.0
+version: 0.4.1
homepage: https://github.com/dart-lang/sdk/tree/master/pkg/native_stack_traces
diff --git a/runtime/tests/vm/dart/use_flag_test_helper.dart b/runtime/tests/vm/dart/use_flag_test_helper.dart
index d6854ac..431fce5 100644
--- a/runtime/tests/vm/dart/use_flag_test_helper.dart
+++ b/runtime/tests/vm/dart/use_flag_test_helper.dart
@@ -116,13 +116,16 @@
print('Running $executable ${args.join(' ')}');
final result = await Process.run(executable, args);
+ print('Subcommand terminated with exit code ${result.exitCode}.');
if (result.stdout.isNotEmpty) {
print('Subcommand stdout:');
print(result.stdout);
}
- if (result.stderr.isNotEmpty) {
- print('Subcommand stderr:');
- print(result.stderr);
+ if (result.exitCode != 0) {
+ if (result.stderr.isNotEmpty) {
+ print('Subcommand stderr:');
+ print(result.stderr);
+ }
}
return result;
diff --git a/runtime/tests/vm/dart/v8_snapshot_profile_writer_test.dart b/runtime/tests/vm/dart/v8_snapshot_profile_writer_test.dart
index aa7eac0..8719b76 100644
--- a/runtime/tests/vm/dart/v8_snapshot_profile_writer_test.dart
+++ b/runtime/tests/vm/dart/v8_snapshot_profile_writer_test.dart
@@ -6,6 +6,7 @@
import 'dart:io';
import 'package:expect/expect.dart';
+import 'package:native_stack_traces/elf.dart';
import 'package:path/path.dart' as path;
import 'package:vm_snapshot_analysis/v8_profile.dart';
@@ -14,33 +15,112 @@
// Used to ensure we don't have multiple equivalent calls to test.
final _seenDescriptions = <String>{};
-Future<void> test(String dillPath,
+Snapshot testProfile(String profilePath) {
+ final profile =
+ Snapshot.fromJson(jsonDecode(File(profilePath).readAsStringSync()));
+
+ // Verify that there are no "unknown" nodes. These are emitted when we see a
+ // reference to an some object but no other metadata about the object was
+ // recorded. We should at least record the type for every object in the
+ // graph (in some cases the shallow size can legitimately be 0, e.g. for
+ // "base objects" not written to the snapshot or artificial nodes).
+ for (final node in profile.nodes) {
+ Expect.notEquals("Unknown", node.type, "unknown node ${node}");
+ }
+
+ final root = profile.nodeAt(0);
+ final reachable = <Node>{};
+
+ // HeapSnapshotWorker.HeapSnapshot.calculateDistances (from HeapSnapshot.js)
+ // assumes that the graph root has at most one edge to any other node
+ // (most likely an oversight).
+ for (final edge in root.edges) {
+ Expect.isTrue(
+ reachable.add(edge.target),
+ "root\n\n$root\n\nhas multiple edges to node\n\n${edge.target}:\n\n"
+ "${root.edges.where((e) => e.target == edge.target).toList()}");
+ }
+
+ // Check that all other nodes are reachable from the root.
+ final stack = <Node>[...reachable];
+ while (!stack.isEmpty) {
+ final next = stack.removeLast();
+ for (final edge in next.edges) {
+ if (reachable.add(edge.target)) {
+ stack.add(edge.target);
+ }
+ }
+ }
+
+ final unreachable =
+ profile.nodes.skip(1).where((Node n) => !reachable.contains(n)).toSet();
+ Expect.isEmpty(unreachable);
+
+ return profile;
+}
+
+Future<void> testJIT(String dillPath) async {
+ final description = 'jit';
+ Expect.isTrue(_seenDescriptions.add(description),
+ "test configuration $description would be run multiple times");
+
+ await withTempDir('v8-snapshot-profile-$description', (String tempDir) async {
+ // Generate the snapshot profile.
+ final profilePath = path.join(tempDir, 'profile.heapsnapshot');
+ final vmTextPath = path.join(tempDir, 'vm_instructions.bin');
+ final isolateTextPath = path.join(tempDir, 'isolate_instructions.bin');
+ final vmDataPath = path.join(tempDir, 'vm_data.bin');
+ final isolateDataPath = path.join(tempDir, 'isolate_data.bin');
+
+ await run(genSnapshot, <String>[
+ '--snapshot-kind=core-jit',
+ '--vm_snapshot_instructions=$vmTextPath',
+ '--isolate_snapshot_instructions=$isolateTextPath',
+ '--vm_snapshot_data=$vmDataPath',
+ '--isolate_snapshot_data=$isolateDataPath',
+ "--write-v8-snapshot-profile-to=$profilePath",
+ dillPath,
+ ]);
+
+ print("Snapshot profile generated at $profilePath.");
+
+ final profile = testProfile(profilePath);
+
+ // Verify that the total size of the snapshot text and data sections is
+ // the same as the sum of the shallow sizes of all objects in the profile.
+ // This ensures that all bytes are accounted for in some way.
+ final actualSize = await File(vmTextPath).length() +
+ await File(isolateTextPath).length() +
+ await File(vmDataPath).length() +
+ await File(isolateDataPath).length();
+ final expectedSize =
+ profile.nodes.fold<int>(0, (size, n) => size + n.selfSize);
+
+ Expect.equals(expectedSize, actualSize, "failed on $description snapshot");
+ });
+}
+
+Future<void> testAOT(String dillPath,
{bool useAsm = false,
bool useBare = true,
bool forceDrops = false,
bool useDispatch = true,
- bool stripUtil = false, // Note: forced if useAsm.
- bool stripFlag = false, // Note: forced if !stripUtil (and thus !useAsm).
+ bool stripUtil = false, // Note: forced true if useAsm.
+ bool stripFlag = false,
bool disassemble = false}) async {
- // We don't assume forced disassembler support in Product mode, so skip any
- // disassembly test.
- if (!const bool.fromEnvironment('dart.vm.product') && disassemble) {
- return;
+ if (const bool.fromEnvironment('dart.vm.product') && disassemble) {
+ Expect.isFalse(disassemble, 'no use of disassembler in PRODUCT mode');
}
- // The assembler may add extra unnecessary information to the compiled
- // snapshot whether or not we generate DWARF information in the assembly, so
- // we force the use of a utility when generating assembly.
+ // For assembly, we can't test the sizes of the snapshot sections, since we
+ // don't have a Mach-O reader for Mac snapshots and for ELF, the assembler
+ // merges the text/data sections and the VM/isolate section symbols may not
+ // have length information. Thus, we force external stripping so we can test
+ // the approximate size of the stripped snapshot.
if (useAsm) {
stripUtil = true;
}
- // We must strip the output in some way when generating ELF snapshots,
- // else the debugging information added will cause the test to fail.
- if (!stripUtil) {
- stripFlag = true;
- }
-
final descriptionBuilder = StringBuffer()..write(useAsm ? 'assembly' : 'elf');
if (!useBare) {
descriptionBuilder.write('-nonbare');
@@ -70,7 +150,7 @@
final profilePath = path.join(tempDir, 'profile.heapsnapshot');
final snapshotPath = path.join(tempDir, 'test.snap');
final commonSnapshotArgs = [
- if (stripFlag) '--strip',
+ if (stripFlag) '--strip', // gen_snapshot specific and not a VM flag.
useBare ? '--use-bare-instructions' : '--no-use-bare-instructions',
"--write-v8-snapshot-profile-to=$profilePath",
if (forceDrops) ...[
@@ -78,9 +158,8 @@
'--no-retain-function-objects',
'--no-retain-code-objects'
],
- if (!useDispatch) '--no-use-table-dispatch',
- if (disassemble) '--disassemble',
- '--ignore-unrecognized-flags',
+ useDispatch ? '--use-table-dispatch' : '--no-use-table-dispatch',
+ if (disassemble) '--disassemble', // Not defined in PRODUCT mode.
dillPath,
];
@@ -102,70 +181,70 @@
]);
}
- String strippedPath;
- if (stripUtil) {
- strippedPath = snapshotPath + '.stripped';
- await stripSnapshot(snapshotPath, strippedPath, forceElf: !useAsm);
- } else {
- strippedPath = snapshotPath;
- }
-
+ print("Snapshot generated at $snapshotPath.");
print("Snapshot profile generated at $profilePath.");
- final profile =
- Snapshot.fromJson(jsonDecode(File(profilePath).readAsStringSync()));
+ final profile = testProfile(profilePath);
- // Verify that there are no "unknown" nodes. These are emitted when we see a
- // reference to an some object but no other metadata about the object was
- // recorded. We should at least record the type for every object in the
- // graph (in some cases the shallow size can legitimately be 0, e.g. for
- // "base objects" not written to the snapshot or artificial nodes).
- for (final node in profile.nodes) {
- Expect.notEquals("Unknown", node.type, "unknown node ${node}");
+ final expectedSize =
+ profile.nodes.fold<int>(0, (size, n) => size + n.selfSize);
+
+ var checkedSize = false;
+ if (!useAsm) {
+ // Verify that the total size of the snapshot text and data sections is
+ // the same as the sum of the shallow sizes of all objects in the profile.
+ // This ensures that all bytes are accounted for in some way.
+ final elf = Elf.fromFile(snapshotPath);
+ Expect.isNotNull(elf);
+ elf!; // To refine type to non-nullable version.
+
+ final vmTextSectionSymbol = elf.dynamicSymbolFor(vmSymbolName);
+ Expect.isNotNull(vmTextSectionSymbol);
+ final vmDataSectionSymbol = elf.dynamicSymbolFor(vmDataSymbolName);
+ Expect.isNotNull(vmDataSectionSymbol);
+ final isolateTextSectionSymbol = elf.dynamicSymbolFor(isolateSymbolName);
+ Expect.isNotNull(isolateTextSectionSymbol);
+ final isolateDataSectionSymbol =
+ elf.dynamicSymbolFor(isolateDataSymbolName);
+ Expect.isNotNull(isolateDataSectionSymbol);
+
+ final actualSize = vmTextSectionSymbol!.size +
+ vmDataSectionSymbol!.size +
+ isolateTextSectionSymbol!.size +
+ isolateDataSectionSymbol!.size;
+
+ Expect.equals(
+ expectedSize, actualSize, "failed on $description snapshot");
+ checkedSize = true;
}
- final root = profile.nodeAt(0);
- final reachable = <Node>{};
-
- // HeapSnapshotWorker.HeapSnapshot.calculateDistances (from HeapSnapshot.js)
- // assumes that the graph root has at most one edge to any other node
- // (most likely an oversight).
- for (final edge in root.edges) {
- Expect.isTrue(
- reachable.add(edge.target),
- "root\n\n$root\n\nhas multiple edges to node\n\n${edge.target}:\n\n"
- "${root.edges.where((e) => e.target == edge.target).toList()}");
- }
-
- // Check that all other nodes are reachable from the root.
- final stack = <Node>[...reachable];
- while (!stack.isEmpty) {
- final next = stack.removeLast();
- for (final edge in next.edges) {
- if (reachable.add(edge.target)) {
- stack.add(edge.target);
- }
+ if (stripUtil || stripFlag) {
+ var strippedSnapshotPath = snapshotPath;
+ if (stripUtil) {
+ strippedSnapshotPath = snapshotPath + '.stripped';
+ await stripSnapshot(snapshotPath, strippedSnapshotPath,
+ forceElf: !useAsm);
+ print("Stripped snapshot generated at $strippedSnapshotPath.");
}
+
+ // Verify that the actual size of the stripped snapshot is close to the
+ // sum of the shallow sizes of all objects in the profile. They will not
+ // be exactly equal because of global headers and padding.
+ final actualSize = await File(strippedSnapshotPath).length();
+
+ // See Elf::kPages in runtime/vm/elf.h, which is also used for assembly
+ // padding.
+ final segmentAlignment = 16 * 1024;
+ // Not every byte is accounted for by the snapshot profile, and data and
+ // instruction segments are padded to an alignment boundary.
+ final tolerance = 0.03 * actualSize + 2 * segmentAlignment;
+
+ Expect.approxEquals(expectedSize, actualSize, tolerance,
+ "failed on $description snapshot");
+ checkedSize = true;
}
- final unreachable =
- profile.nodes.skip(1).where((Node n) => !reachable.contains(n)).toSet();
- Expect.isEmpty(unreachable);
-
- // Verify that the actual size of the snapshot is close to the sum of the
- // shallow sizes of all objects in the profile. They will not be exactly
- // equal because of global headers and padding.
- final actual = await File(strippedPath).length();
- final expected = profile.nodes.fold<int>(0, (size, n) => size + n.selfSize);
-
- // See Elf::kPages in runtime/vm/elf.h.
- final segmentAlignment = 16 * 1024;
- // Not every byte is accounted for by the snapshot profile, and data and
- // instruction segments are padded to an alignment boundary.
- final tolerance = 0.03 * actual + 2 * segmentAlignment;
-
- Expect.approxEquals(
- expected, actual, tolerance, "failed on $description snapshot");
+ Expect.isTrue(checkedSize, "no snapshot size checks were performed");
});
}
@@ -264,10 +343,24 @@
await testMacros();
await withTempDir('v8-snapshot-profile-writer', (String tempDir) async {
- // We only need to generate the dill file once.
+ // We only need to generate the dill file once for all JIT tests.
final _thisTestPath = path.join(sdkDir, 'runtime', 'tests', 'vm', 'dart',
'v8_snapshot_profile_writer_test.dart');
- final dillPath = path.join(tempDir, 'test.dill');
+ final jitDillPath = path.join(tempDir, 'jit_test.dill');
+ await run(genKernel, <String>[
+ '--platform',
+ platformDill,
+ ...Platform.executableArguments.where((arg) =>
+ arg.startsWith('--enable-experiment=') ||
+ arg == '--sound-null-safety' ||
+ arg == '--no-sound-null-safety'),
+ '-o',
+ jitDillPath,
+ _thisTestPath
+ ]);
+
+ // We only need to generate the dill file once for all AOT tests.
+ final aotDillPath = path.join(tempDir, 'aot_test.dill');
await run(genKernel, <String>[
'--aot',
'--platform',
@@ -277,26 +370,38 @@
arg == '--sound-null-safety' ||
arg == '--no-sound-null-safety'),
'-o',
- dillPath,
+ aotDillPath,
_thisTestPath
]);
- // Just as a reminder (these rules are applied in order inside test):
- // If useAsm is true, then stripUtil is forced (as the assembler may add
- // extra information that needs stripping).
- // If stripUtil is false, then stripFlag is forced (as the output must be
- // stripped in some way to remove DWARF information).
+ // Just as a reminder for AOT tests:
+ // * If useAsm is true, then stripUtil is forced (as the assembler may add
+ // extra information that needs stripping), so no need to specify
+ // stripUtil for useAsm tests.
- // Test stripped ELF generation directly.
- await test(dillPath);
- await test(dillPath, useBare: false);
- await test(dillPath, forceDrops: true);
- await test(dillPath, forceDrops: true, useBare: false);
- await test(dillPath, forceDrops: true, useDispatch: false);
- await test(dillPath, forceDrops: true, useDispatch: false, useBare: false);
+ // Test profile generation with a core JIT snapshot.
+ await testJIT(jitDillPath);
- // Regression test for dartbug.com/41149.
- await test(dillPath, useBare: false, disassemble: true);
+ // Test unstripped ELF generation directly.
+ await testAOT(aotDillPath);
+ await testAOT(aotDillPath, useBare: false);
+ await testAOT(aotDillPath, forceDrops: true);
+ await testAOT(aotDillPath, forceDrops: true, useBare: false);
+ await testAOT(aotDillPath, forceDrops: true, useDispatch: false);
+ await testAOT(aotDillPath,
+ forceDrops: true, useDispatch: false, useBare: false);
+
+ // Test flag-stripped ELF generation.
+ await testAOT(aotDillPath, stripFlag: true);
+ await testAOT(aotDillPath, useBare: false, stripFlag: true);
+
+ // Since we can't force disassembler support after the fact when running
+ // in PRODUCT mode, skip any --disassemble tests. Do these tests last as
+ // they have lots of output and so the log will be truncated.
+ if (!const bool.fromEnvironment('dart.vm.product')) {
+ // Regression test for dartbug.com/41149.
+ await testAOT(aotDillPath, useBare: false, disassemble: true);
+ }
// We neither generate assembly nor have a stripping utility on Windows.
if (Platform.isWindows) {
@@ -308,24 +413,24 @@
if (Platform.isMacOS && clangBuildToolsDir == null) {
printSkip('ELF external stripping test');
} else {
- // Test unstripped ELF generation that is then stripped externally.
- await test(dillPath, stripUtil: true);
- await test(dillPath, stripUtil: true, useBare: false);
+ // Test unstripped ELF generation that is then externally stripped.
+ await testAOT(aotDillPath, stripUtil: true);
+ await testAOT(aotDillPath, stripUtil: true, useBare: false);
}
// TODO(sstrickl): Currently we can't assemble for SIMARM64 on MacOSX.
- // For example, the test runner still uses blobs for dartkp-mac-*-simarm64.
- // Change assembleSnapshot and remove this check when we can.
+ // For example, the test runner still uses blobs for
+ // dartkp-mac-*-simarm64. Change assembleSnapshot and remove this check
+ // when we can.
if (Platform.isMacOS && buildDir.endsWith('SIMARM64')) {
printSkip('assembly tests');
return;
}
-
- // Test unstripped assembly generation that is then compiled and stripped.
- await test(dillPath, useAsm: true);
- await test(dillPath, useAsm: true, useBare: false);
- // Test stripped assembly generation that is then compiled and stripped.
- await test(dillPath, useAsm: true, stripFlag: true);
- await test(dillPath, useAsm: true, stripFlag: true, useBare: false);
+ // Test unstripped assembly generation that is then externally stripped.
+ await testAOT(aotDillPath, useAsm: true);
+ await testAOT(aotDillPath, useAsm: true, useBare: false);
+ // Test stripped assembly generation that is then externally stripped.
+ await testAOT(aotDillPath, useAsm: true, stripFlag: true);
+ await testAOT(aotDillPath, useAsm: true, stripFlag: true, useBare: false);
});
}
diff --git a/runtime/tests/vm/dart_2/use_flag_test_helper.dart b/runtime/tests/vm/dart_2/use_flag_test_helper.dart
index 24f0687..650a9bf 100644
--- a/runtime/tests/vm/dart_2/use_flag_test_helper.dart
+++ b/runtime/tests/vm/dart_2/use_flag_test_helper.dart
@@ -114,13 +114,16 @@
print('Running $executable ${args.join(' ')}');
final result = await Process.run(executable, args);
+ print('Subcommand terminated with exit code ${result.exitCode}.');
if (result.stdout.isNotEmpty) {
print('Subcommand stdout:');
print(result.stdout);
}
- if (result.stderr.isNotEmpty) {
- print('Subcommand stderr:');
- print(result.stderr);
+ if (result.exitCode != 0) {
+ if (result.stderr.isNotEmpty) {
+ print('Subcommand stderr:');
+ print(result.stderr);
+ }
}
return result;
diff --git a/runtime/tests/vm/dart_2/v8_snapshot_profile_writer_test.dart b/runtime/tests/vm/dart_2/v8_snapshot_profile_writer_test.dart
index 7977a71..0628aa0 100644
--- a/runtime/tests/vm/dart_2/v8_snapshot_profile_writer_test.dart
+++ b/runtime/tests/vm/dart_2/v8_snapshot_profile_writer_test.dart
@@ -6,6 +6,7 @@
import 'dart:io';
import 'package:expect/expect.dart';
+import 'package:native_stack_traces/elf.dart';
import 'package:path/path.dart' as path;
import 'package:vm_snapshot_analysis/v8_profile.dart';
@@ -14,33 +15,112 @@
// Used to ensure we don't have multiple equivalent calls to test.
final _seenDescriptions = <String>{};
-Future<void> test(String dillPath,
+Snapshot testProfile(String profilePath) {
+ final profile =
+ Snapshot.fromJson(jsonDecode(File(profilePath).readAsStringSync()));
+
+ // Verify that there are no "unknown" nodes. These are emitted when we see a
+ // reference to an some object but no other metadata about the object was
+ // recorded. We should at least record the type for every object in the
+ // graph (in some cases the shallow size can legitimately be 0, e.g. for
+ // "base objects" not written to the snapshot or artificial nodes).
+ for (final node in profile.nodes) {
+ Expect.notEquals("Unknown", node.type, "unknown node ${node}");
+ }
+
+ final root = profile.nodeAt(0);
+ final reachable = <Node>{};
+
+ // HeapSnapshotWorker.HeapSnapshot.calculateDistances (from HeapSnapshot.js)
+ // assumes that the graph root has at most one edge to any other node
+ // (most likely an oversight).
+ for (final edge in root.edges) {
+ Expect.isTrue(
+ reachable.add(edge.target),
+ "root\n\n$root\n\nhas multiple edges to node\n\n${edge.target}:\n\n"
+ "${root.edges.where((e) => e.target == edge.target).toList()}");
+ }
+
+ // Check that all other nodes are reachable from the root.
+ final stack = <Node>[...reachable];
+ while (!stack.isEmpty) {
+ final next = stack.removeLast();
+ for (final edge in next.edges) {
+ if (reachable.add(edge.target)) {
+ stack.add(edge.target);
+ }
+ }
+ }
+
+ final unreachable =
+ profile.nodes.skip(1).where((Node n) => !reachable.contains(n)).toSet();
+ Expect.isEmpty(unreachable);
+
+ return profile;
+}
+
+Future<void> testJIT(String dillPath) async {
+ final description = 'jit';
+ Expect.isTrue(_seenDescriptions.add(description),
+ "test configuration $description would be run multiple times");
+
+ await withTempDir('v8-snapshot-profile-$description', (String tempDir) async {
+ // Generate the snapshot profile.
+ final profilePath = path.join(tempDir, 'profile.heapsnapshot');
+ final vmTextPath = path.join(tempDir, 'vm_instructions.bin');
+ final isolateTextPath = path.join(tempDir, 'isolate_instructions.bin');
+ final vmDataPath = path.join(tempDir, 'vm_data.bin');
+ final isolateDataPath = path.join(tempDir, 'isolate_data.bin');
+
+ await run(genSnapshot, <String>[
+ '--snapshot-kind=core-jit',
+ '--vm_snapshot_instructions=$vmTextPath',
+ '--isolate_snapshot_instructions=$isolateTextPath',
+ '--vm_snapshot_data=$vmDataPath',
+ '--isolate_snapshot_data=$isolateDataPath',
+ "--write-v8-snapshot-profile-to=$profilePath",
+ dillPath,
+ ]);
+
+ print("Snapshot profile generated at $profilePath.");
+
+ final profile = testProfile(profilePath);
+
+ // Verify that the total size of the snapshot text and data sections is
+ // the same as the sum of the shallow sizes of all objects in the profile.
+ // This ensures that all bytes are accounted for in some way.
+ final actualSize = await File(vmTextPath).length() +
+ await File(isolateTextPath).length() +
+ await File(vmDataPath).length() +
+ await File(isolateDataPath).length();
+ final expectedSize =
+ profile.nodes.fold<int>(0, (size, n) => size + n.selfSize);
+
+ Expect.equals(expectedSize, actualSize, "failed on $description snapshot");
+ });
+}
+
+Future<void> testAOT(String dillPath,
{bool useAsm = false,
bool useBare = true,
bool forceDrops = false,
bool useDispatch = true,
- bool stripUtil = false, // Note: forced if useAsm.
- bool stripFlag = false, // Note: forced if !stripUtil (and thus !useAsm).
+ bool stripUtil = false, // Note: forced true if useAsm.
+ bool stripFlag = false,
bool disassemble = false}) async {
- // We don't assume forced disassembler support in Product mode, so skip any
- // disassembly test.
- if (!const bool.fromEnvironment('dart.vm.product') && disassemble) {
- return;
+ if (const bool.fromEnvironment('dart.vm.product') && disassemble) {
+ Expect.isFalse(disassemble, 'no use of disassembler in PRODUCT mode');
}
- // The assembler may add extra unnecessary information to the compiled
- // snapshot whether or not we generate DWARF information in the assembly, so
- // we force the use of a utility when generating assembly.
+ // For assembly, we can't test the sizes of the snapshot sections, since we
+ // don't have a Mach-O reader for Mac snapshots and for ELF, the assembler
+ // merges the text/data sections and the VM/isolate section symbols may not
+ // have length information. Thus, we force external stripping so we can test
+ // the approximate size of the stripped snapshot.
if (useAsm) {
stripUtil = true;
}
- // We must strip the output in some way when generating ELF snapshots,
- // else the debugging information added will cause the test to fail.
- if (!stripUtil) {
- stripFlag = true;
- }
-
final descriptionBuilder = StringBuffer()..write(useAsm ? 'assembly' : 'elf');
if (!useBare) {
descriptionBuilder.write('-nonbare');
@@ -70,7 +150,7 @@
final profilePath = path.join(tempDir, 'profile.heapsnapshot');
final snapshotPath = path.join(tempDir, 'test.snap');
final commonSnapshotArgs = [
- if (stripFlag) '--strip',
+ if (stripFlag) '--strip', // gen_snapshot specific and not a VM flag.
useBare ? '--use-bare-instructions' : '--no-use-bare-instructions',
"--write-v8-snapshot-profile-to=$profilePath",
if (forceDrops) ...[
@@ -78,9 +158,8 @@
'--no-retain-function-objects',
'--no-retain-code-objects'
],
- if (!useDispatch) '--no-use-table-dispatch',
- if (disassemble) '--disassemble',
- '--ignore-unrecognized-flags',
+ useDispatch ? '--use-table-dispatch' : '--no-use-table-dispatch',
+ if (disassemble) '--disassemble', // Not defined in PRODUCT mode.
dillPath,
];
@@ -110,62 +189,69 @@
strippedPath = snapshotPath;
}
+ print("Snapshot generated at $snapshotPath.");
print("Snapshot profile generated at $profilePath.");
- final profile =
- Snapshot.fromJson(jsonDecode(File(profilePath).readAsStringSync()));
+ final profile = testProfile(profilePath);
- // Verify that there are no "unknown" nodes. These are emitted when we see a
- // reference to an some object but no other metadata about the object was
- // recorded. We should at least record the type for every object in the
- // graph (in some cases the shallow size can legitimately be 0, e.g. for
- // "base objects" not written to the snapshot or artificial nodes).
- for (final node in profile.nodes) {
- Expect.notEquals("Unknown", node.type, "unknown node ${node}");
+ final expectedSize =
+ profile.nodes.fold<int>(0, (size, n) => size + n.selfSize);
+
+ var checkedSize = false;
+ if (!useAsm) {
+ // Verify that the total size of the snapshot text and data sections is
+ // the same as the sum of the shallow sizes of all objects in the profile.
+ // This ensures that all bytes are accounted for in some way.
+ final elf = Elf.fromFile(snapshotPath);
+ Expect.isNotNull(elf);
+
+ final vmTextSectionSymbol = elf.dynamicSymbolFor(vmSymbolName);
+ Expect.isNotNull(vmTextSectionSymbol);
+ final vmDataSectionSymbol = elf.dynamicSymbolFor(vmDataSymbolName);
+ Expect.isNotNull(vmDataSectionSymbol);
+ final isolateTextSectionSymbol = elf.dynamicSymbolFor(isolateSymbolName);
+ Expect.isNotNull(isolateTextSectionSymbol);
+ final isolateDataSectionSymbol =
+ elf.dynamicSymbolFor(isolateDataSymbolName);
+ Expect.isNotNull(isolateDataSectionSymbol);
+
+ final actualSize = vmTextSectionSymbol.size +
+ vmDataSectionSymbol.size +
+ isolateTextSectionSymbol.size +
+ isolateDataSectionSymbol.size;
+
+ Expect.equals(
+ expectedSize, actualSize, "failed on $description snapshot");
+ checkedSize = true;
}
- final root = profile.nodeAt(0);
- final reachable = <Node>{};
-
- // HeapSnapshotWorker.HeapSnapshot.calculateDistances (from HeapSnapshot.js)
- // assumes that the graph root has at most one edge to any other node
- // (most likely an oversight).
- for (final edge in root.edges) {
- Expect.isTrue(
- reachable.add(edge.target),
- "root\n\n$root\n\nhas multiple edges to node\n\n${edge.target}:\n\n"
- "${root.edges.where((e) => e.target == edge.target).toList()}");
- }
-
- // Check that all other nodes are reachable from the root.
- final stack = <Node>[...reachable];
- while (!stack.isEmpty) {
- final next = stack.removeLast();
- for (final edge in next.edges) {
- if (reachable.add(edge.target)) {
- stack.add(edge.target);
- }
+ if (stripUtil || stripFlag) {
+ var strippedSnapshotPath = snapshotPath;
+ if (stripUtil) {
+ strippedSnapshotPath = snapshotPath + '.stripped';
+ await stripSnapshot(snapshotPath, strippedSnapshotPath,
+ forceElf: !useAsm);
+ print("Stripped snapshot generated at $strippedSnapshotPath.");
}
+
+ // Verify that the actual size of the stripped snapshot is close to the
+ // sum of the shallow sizes of all objects in the profile. They will not
+ // be exactly equal because of global headers and padding.
+ final actualSize = await File(strippedSnapshotPath).length();
+
+ // See Elf::kPages in runtime/vm/elf.h, which is also used for assembly
+ // padding.
+ final segmentAlignment = 16 * 1024;
+ // Not every byte is accounted for by the snapshot profile, and data and
+ // instruction segments are padded to an alignment boundary.
+ final tolerance = 0.03 * actualSize + 2 * segmentAlignment;
+
+ Expect.approxEquals(expectedSize, actualSize, tolerance,
+ "failed on $description snapshot");
+ checkedSize = true;
}
- final unreachable =
- profile.nodes.skip(1).where((Node n) => !reachable.contains(n)).toSet();
- Expect.isEmpty(unreachable);
-
- // Verify that the actual size of the snapshot is close to the sum of the
- // shallow sizes of all objects in the profile. They will not be exactly
- // equal because of global headers and padding.
- final actual = await File(strippedPath).length();
- final expected = profile.nodes.fold<int>(0, (size, n) => size + n.selfSize);
-
- // See Elf::kPages in runtime/vm/elf.h.
- final segmentAlignment = 16 * 1024;
- // Not every byte is accounted for by the snapshot profile, and data and
- // instruction segments are padded to an alignment boundary.
- final tolerance = 0.03 * actual + 2 * segmentAlignment;
-
- Expect.approxEquals(
- expected, actual, tolerance, "failed on $description snapshot");
+ Expect.isTrue(checkedSize, "no snapshot size checks were performed");
});
}
@@ -264,35 +350,52 @@
await testMacros();
await withTempDir('v8-snapshot-profile-writer', (String tempDir) async {
- // We only need to generate the dill file once.
- final _thisTestPath = path.join(sdkDir, 'runtime', 'tests', 'vm', 'dart_2',
+ // We only need to generate the dill file once for all JIT tests.
+ final _thisTestPath = path.join(sdkDir, 'runtime', 'tests', 'vm', 'dart',
'v8_snapshot_profile_writer_test.dart');
- final dillPath = path.join(tempDir, 'test.dill');
+ final jitDillPath = path.join(tempDir, 'jit_test.dill');
+ await run(genKernel,
+ <String>['--platform', platformDill, '-o', jitDillPath, _thisTestPath]);
+
+ // We only need to generate the dill file once for all AOT tests.
+ final aotDillPath = path.join(tempDir, 'aot_test.dill');
await run(genKernel, <String>[
'--aot',
'--platform',
platformDill,
'-o',
- dillPath,
+ aotDillPath,
_thisTestPath
]);
- // Just as a reminder (these rules are applied in order inside test):
- // If useAsm is true, then stripUtil is forced (as the assembler may add
- // extra information that needs stripping).
- // If stripUtil is false, then stripFlag is forced (as the output must be
- // stripped in some way to remove DWARF information).
+ // Just as a reminder for AOT tests:
+ // * If useAsm is true, then stripUtil is forced (as the assembler may add
+ // extra information that needs stripping), so no need to specify
+ // stripUtil for useAsm tests.
- // Test stripped ELF generation directly.
- await test(dillPath);
- await test(dillPath, useBare: false);
- await test(dillPath, forceDrops: true);
- await test(dillPath, forceDrops: true, useBare: false);
- await test(dillPath, forceDrops: true, useDispatch: false);
- await test(dillPath, forceDrops: true, useDispatch: false, useBare: false);
+ // Test profile generation with a core JIT snapshot.
+ await testJIT(jitDillPath);
- // Regression test for dartbug.com/41149.
- await test(dillPath, useBare: false, disassemble: true);
+ // Test unstripped ELF generation directly.
+ await testAOT(aotDillPath);
+ await testAOT(aotDillPath, useBare: false);
+ await testAOT(aotDillPath, forceDrops: true);
+ await testAOT(aotDillPath, forceDrops: true, useBare: false);
+ await testAOT(aotDillPath, forceDrops: true, useDispatch: false);
+ await testAOT(aotDillPath,
+ forceDrops: true, useDispatch: false, useBare: false);
+
+ // Test flag-stripped ELF generation.
+ await testAOT(aotDillPath, stripFlag: true);
+ await testAOT(aotDillPath, useBare: false, stripFlag: true);
+
+ // Since we can't force disassembler support after the fact when running
+ // in PRODUCT mode, skip any --disassemble tests. Do these tests last as
+ // they have lots of output and so the log will be truncated.
+ if (!const bool.fromEnvironment('dart.vm.product')) {
+ // Regression test for dartbug.com/41149.
+ await testAOT(aotDillPath, useBare: false, disassemble: true);
+ }
// We neither generate assembly nor have a stripping utility on Windows.
if (Platform.isWindows) {
@@ -304,24 +407,24 @@
if (Platform.isMacOS && clangBuildToolsDir == null) {
printSkip('ELF external stripping test');
} else {
- // Test unstripped ELF generation that is then stripped externally.
- await test(dillPath, stripUtil: true);
- await test(dillPath, stripUtil: true, useBare: false);
+ // Test unstripped ELF generation that is then externally stripped.
+ await testAOT(aotDillPath, stripUtil: true);
+ await testAOT(aotDillPath, stripUtil: true, useBare: false);
}
// TODO(sstrickl): Currently we can't assemble for SIMARM64 on MacOSX.
- // For example, the test runner still uses blobs for dartkp-mac-*-simarm64.
- // Change assembleSnapshot and remove this check when we can.
+ // For example, the test runner still uses blobs for
+ // dartkp-mac-*-simarm64. Change assembleSnapshot and remove this check
+ // when we can.
if (Platform.isMacOS && buildDir.endsWith('SIMARM64')) {
printSkip('assembly tests');
return;
}
-
- // Test unstripped assembly generation that is then compiled and stripped.
- await test(dillPath, useAsm: true);
- await test(dillPath, useAsm: true, useBare: false);
- // Test stripped assembly generation that is then compiled and stripped.
- await test(dillPath, useAsm: true, stripFlag: true);
- await test(dillPath, useAsm: true, stripFlag: true, useBare: false);
+ // Test unstripped assembly generation that is then externally stripped.
+ await testAOT(aotDillPath, useAsm: true);
+ await testAOT(aotDillPath, useAsm: true, useBare: false);
+ // Test stripped assembly generation that is then externally stripped.
+ await testAOT(aotDillPath, useAsm: true, stripFlag: true);
+ await testAOT(aotDillPath, useAsm: true, stripFlag: true, useBare: false);
});
}
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 4689812..851945b 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -163,6 +163,9 @@
intptr_t start_size = serializer->bytes_written();
intptr_t start_data = serializer->GetDataSize();
intptr_t start_objects = serializer->next_ref_index();
+ uint64_t cid_and_canonical =
+ (static_cast<uint64_t>(cid_) << 1) | (is_canonical() ? 0x1 : 0x0);
+ serializer->Write<uint64_t>(cid_and_canonical);
WriteAlloc(serializer);
intptr_t stop_size = serializer->bytes_written();
intptr_t stop_data = serializer->GetDataSize();
@@ -176,7 +179,9 @@
}
size_ += (stop_size - start_size) + (stop_data - start_data);
num_objects_ += (stop_objects - start_objects);
- target_memory_size_ += num_objects_ * target_instance_size_;
+ if (target_instance_size_ != kSizeVaries) {
+ target_memory_size_ += num_objects_ * target_instance_size_;
+ }
}
void SerializationCluster::WriteAndMeasureFill(Serializer* serializer) {
@@ -226,7 +231,9 @@
class ClassSerializationCluster : public SerializationCluster {
public:
explicit ClassSerializationCluster(intptr_t num_cids)
- : SerializationCluster("Class", compiler::target::Class::InstanceSize()),
+ : SerializationCluster("Class",
+ kClassCid,
+ compiler::target::Class::InstanceSize()),
predefined_(kNumPredefinedCids),
objects_(num_cids) {}
~ClassSerializationCluster() {}
@@ -252,7 +259,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kClassCid);
intptr_t count = predefined_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -339,7 +345,7 @@
ClassDeserializationCluster() : DeserializationCluster("Class") {}
~ClassDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
predefined_start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
intptr_t count = d->ReadUnsigned();
@@ -361,7 +367,7 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
ClassTable* table = d->isolate_group()->class_table();
for (intptr_t id = predefined_start_index_; id < predefined_stop_index_;
@@ -482,10 +488,12 @@
bool kAllCanonicalObjectsAreIncludedIntoSet = true>
class CanonicalSetSerializationCluster : public SerializationCluster {
protected:
- CanonicalSetSerializationCluster(bool represents_canonical_set,
+ CanonicalSetSerializationCluster(intptr_t cid,
+ bool is_canonical,
+ bool represents_canonical_set,
const char* name,
intptr_t target_instance_size = 0)
- : SerializationCluster(name, target_instance_size),
+ : SerializationCluster(name, cid, target_instance_size, is_canonical),
represents_canonical_set_(represents_canonical_set) {}
virtual bool IsInCanonicalSet(Serializer* s, PointerType ptr) {
@@ -581,13 +589,15 @@
template <typename SetType, bool kAllCanonicalObjectsAreIncludedIntoSet = true>
class CanonicalSetDeserializationCluster : public DeserializationCluster {
public:
- CanonicalSetDeserializationCluster(bool is_root_unit, const char* name)
- : DeserializationCluster(name),
+ CanonicalSetDeserializationCluster(bool is_canonical,
+ bool is_root_unit,
+ const char* name)
+ : DeserializationCluster(name, is_canonical),
is_root_unit_(is_root_unit),
table_(Array::Handle()) {}
- void BuildCanonicalSetFromLayout(Deserializer* d, bool is_canonical) {
- if (!is_root_unit_ || !is_canonical) {
+ void BuildCanonicalSetFromLayout(Deserializer* d) {
+ if (!is_root_unit_ || !is_canonical()) {
return;
}
@@ -681,8 +691,11 @@
TypeArguments,
TypeArgumentsPtr> {
public:
- explicit TypeArgumentsSerializationCluster(bool represents_canonical_set)
- : CanonicalSetSerializationCluster(represents_canonical_set,
+ TypeArgumentsSerializationCluster(bool is_canonical,
+ bool represents_canonical_set)
+ : CanonicalSetSerializationCluster(kTypeArgumentsCid,
+ is_canonical,
+ represents_canonical_set,
"TypeArguments") {}
~TypeArgumentsSerializationCluster() {}
@@ -698,7 +711,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kTypeArgumentsCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
ReorderObjects(s);
@@ -738,11 +750,14 @@
class TypeArgumentsDeserializationCluster
: public CanonicalSetDeserializationCluster<CanonicalTypeArgumentsSet> {
public:
- explicit TypeArgumentsDeserializationCluster(bool is_root_unit)
- : CanonicalSetDeserializationCluster(is_root_unit, "TypeArguments") {}
+ explicit TypeArgumentsDeserializationCluster(bool is_canonical,
+ bool is_root_unit)
+ : CanonicalSetDeserializationCluster(is_canonical,
+ is_root_unit,
+ "TypeArguments") {}
~TypeArgumentsDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -752,16 +767,16 @@
TypeArguments::InstanceSize(length)));
}
stop_index_ = d->next_index();
- BuildCanonicalSetFromLayout(d, stamp_canonical);
+ BuildCanonicalSetFromLayout(d);
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
TypeArgumentsPtr type_args = static_cast<TypeArgumentsPtr>(d->Ref(id));
const intptr_t length = d->ReadUnsigned();
Deserializer::InitializeHeader(type_args, kTypeArgumentsCid,
TypeArguments::InstanceSize(length),
- stamp_canonical);
+ primary && is_canonical());
type_args->untag()->length_ = Smi::New(length);
type_args->untag()->hash_ = Smi::New(d->Read<int32_t>());
type_args->untag()->nullability_ = Smi::New(d->ReadUnsigned());
@@ -773,13 +788,13 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (!table_.IsNull()) {
auto object_store = d->isolate_group()->object_store();
VerifyCanonicalSet(
d, refs, Array::Handle(object_store->canonical_type_arguments()));
object_store->set_canonical_type_arguments(table_);
- } else if (canonicalize) {
+ } else if (!primary && is_canonical()) {
TypeArguments& type_arg = TypeArguments::Handle(d->zone());
for (intptr_t i = start_index_; i < stop_index_; i++) {
type_arg ^= refs.At(i);
@@ -795,6 +810,7 @@
public:
PatchClassSerializationCluster()
: SerializationCluster("PatchClass",
+ kPatchClassCid,
compiler::target::PatchClass::InstanceSize()) {}
~PatchClassSerializationCluster() {}
@@ -805,7 +821,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kPatchClassCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -836,7 +851,7 @@
PatchClassDeserializationCluster() : DeserializationCluster("PatchClass") {}
~PatchClassDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -847,8 +862,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
PatchClassPtr cls = static_cast<PatchClassPtr>(d->Ref(id));
Deserializer::InitializeHeader(cls, kPatchClassCid,
@@ -868,6 +883,7 @@
public:
FunctionSerializationCluster()
: SerializationCluster("Function",
+ kFunctionCid,
compiler::target::Function::InstanceSize()) {}
~FunctionSerializationCluster() {}
@@ -887,7 +903,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kFunctionCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -948,7 +963,7 @@
FunctionDeserializationCluster() : DeserializationCluster("Function") {}
~FunctionDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -958,8 +973,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
Snapshot::Kind kind = d->kind();
for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ -1015,7 +1030,7 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (d->kind() == Snapshot::kFullAOT) {
Function& func = Function::Handle(d->zone());
for (intptr_t i = start_index_; i < stop_index_; i++) {
@@ -1060,6 +1075,7 @@
public:
ClosureDataSerializationCluster()
: SerializationCluster("ClosureData",
+ kClosureDataCid,
compiler::target::ClosureData::InstanceSize()) {}
~ClosureDataSerializationCluster() {}
@@ -1076,7 +1092,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kClosureDataCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -1111,7 +1126,7 @@
ClosureDataDeserializationCluster() : DeserializationCluster("ClosureData") {}
~ClosureDataDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -1122,8 +1137,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
ClosureDataPtr data = static_cast<ClosureDataPtr>(d->Ref(id));
Deserializer::InitializeHeader(data, kClosureDataCid,
@@ -1150,6 +1165,7 @@
FfiTrampolineDataSerializationCluster()
: SerializationCluster(
"FfiTrampolineData",
+ kFfiTrampolineDataCid,
compiler::target::FfiTrampolineData::InstanceSize()) {}
~FfiTrampolineDataSerializationCluster() {}
@@ -1160,7 +1176,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kFfiTrampolineDataCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -1195,7 +1210,7 @@
: DeserializationCluster("FfiTrampolineData") {}
~FfiTrampolineDataDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -1206,8 +1221,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
FfiTrampolineDataPtr data = static_cast<FfiTrampolineDataPtr>(d->Ref(id));
Deserializer::InitializeHeader(data, kFfiTrampolineDataCid,
@@ -1223,8 +1238,9 @@
class FieldSerializationCluster : public SerializationCluster {
public:
FieldSerializationCluster()
- : SerializationCluster("Field", compiler::target::Field::InstanceSize()) {
- }
+ : SerializationCluster("Field",
+ kFieldCid,
+ compiler::target::Field::InstanceSize()) {}
~FieldSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -1256,7 +1272,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kFieldCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -1316,7 +1331,7 @@
FieldDeserializationCluster() : DeserializationCluster("Field") {}
~FieldDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -1326,8 +1341,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
Snapshot::Kind kind = d->kind();
for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ -1383,7 +1398,7 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
Field& field = Field::Handle(d->zone());
if (!IsolateGroup::Current()->use_field_guards()) {
for (intptr_t i = start_index_; i < stop_index_; i++) {
@@ -1410,6 +1425,7 @@
public:
ScriptSerializationCluster()
: SerializationCluster("Script",
+ kScriptCid,
compiler::target::Script::InstanceSize()) {}
~ScriptSerializationCluster() {}
@@ -1420,7 +1436,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kScriptCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -1461,7 +1476,7 @@
ScriptDeserializationCluster() : DeserializationCluster("Script") {}
~ScriptDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -1471,8 +1486,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
ScriptPtr script = static_cast<ScriptPtr>(d->Ref(id));
Deserializer::InitializeHeader(script, kScriptCid,
@@ -1494,6 +1509,7 @@
public:
LibrarySerializationCluster()
: SerializationCluster("Library",
+ kLibraryCid,
compiler::target::Library::InstanceSize()) {}
~LibrarySerializationCluster() {}
@@ -1504,7 +1520,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kLibraryCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -1539,7 +1554,7 @@
LibraryDeserializationCluster() : DeserializationCluster("Library") {}
~LibraryDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -1549,8 +1564,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
LibraryPtr lib = static_cast<LibraryPtr>(d->Ref(id));
Deserializer::InitializeHeader(lib, kLibraryCid, Library::InstanceSize());
@@ -1576,6 +1591,7 @@
public:
NamespaceSerializationCluster()
: SerializationCluster("Namespace",
+ kNamespaceCid,
compiler::target::Namespace::InstanceSize()) {}
~NamespaceSerializationCluster() {}
@@ -1586,7 +1602,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kNamespaceCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -1614,7 +1629,7 @@
NamespaceDeserializationCluster() : DeserializationCluster("Namespace") {}
~NamespaceDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -1624,8 +1639,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
NamespacePtr ns = static_cast<NamespacePtr>(d->Ref(id));
Deserializer::InitializeHeader(ns, kNamespaceCid,
@@ -1642,6 +1657,7 @@
KernelProgramInfoSerializationCluster()
: SerializationCluster(
"KernelProgramInfo",
+ kKernelProgramInfoCid,
compiler::target::KernelProgramInfo::InstanceSize()) {}
~KernelProgramInfoSerializationCluster() {}
@@ -1652,7 +1668,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kKernelProgramInfoCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -1683,7 +1698,7 @@
: DeserializationCluster("KernelProgramInfo") {}
~KernelProgramInfoDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -1694,8 +1709,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
KernelProgramInfoPtr info = static_cast<KernelProgramInfoPtr>(d->Ref(id));
Deserializer::InitializeHeader(info, kKernelProgramInfoCid,
@@ -1705,7 +1720,7 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
Array& array = Array::Handle(d->zone());
KernelProgramInfo& info = KernelProgramInfo::Handle(d->zone());
for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ -1721,7 +1736,7 @@
class CodeSerializationCluster : public SerializationCluster {
public:
explicit CodeSerializationCluster(Heap* heap)
- : SerializationCluster("Code"), array_(Array::Handle()) {}
+ : SerializationCluster("Code", kCodeCid), array_(Array::Handle()) {}
~CodeSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -1881,7 +1896,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kCodeCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2057,7 +2071,7 @@
CodeDeserializationCluster() : DeserializationCluster("Code") {}
~CodeDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
PageSpace* old_space = d->heap()->old_space();
start_index_ = d->next_index();
d->set_code_start_index(start_index_);
@@ -2087,8 +2101,8 @@
}
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
ReadFill(d, id, false);
}
@@ -2150,7 +2164,7 @@
#endif
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
d->EndInstructions();
#if !defined(PRODUCT)
@@ -2191,7 +2205,8 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class ObjectPoolSerializationCluster : public SerializationCluster {
public:
- ObjectPoolSerializationCluster() : SerializationCluster("ObjectPool") {}
+ ObjectPoolSerializationCluster()
+ : SerializationCluster("ObjectPool", kObjectPoolCid) {}
~ObjectPoolSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -2213,7 +2228,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kObjectPoolCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2283,7 +2297,7 @@
ObjectPoolDeserializationCluster() : DeserializationCluster("ObjectPool") {}
~ObjectPoolDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -2295,8 +2309,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
fill_position_ = d->position();
for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ -2329,7 +2343,7 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (d->is_non_root_unit()) {
// If this is a non-root unit, some pool entries that should be canonical
// may have been replaced be with other objects during canonicalization.
@@ -2410,23 +2424,11 @@
};
#endif
-#if defined(DART_PRECOMPILED_RUNTIME)
-class WeakSerializationReferenceDeserializationCluster
- : public DeserializationCluster {
- public:
- WeakSerializationReferenceDeserializationCluster()
- : DeserializationCluster("WeakSerializationReference") {}
- ~WeakSerializationReferenceDeserializationCluster() {}
-
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {}
- void ReadFill(Deserializer* d, bool stamp_canonical) {}
-};
-#endif
-
#if !defined(DART_PRECOMPILED_RUNTIME)
class PcDescriptorsSerializationCluster : public SerializationCluster {
public:
- PcDescriptorsSerializationCluster() : SerializationCluster("PcDescriptors") {}
+ PcDescriptorsSerializationCluster()
+ : SerializationCluster("PcDescriptors", kPcDescriptorsCid) {}
~PcDescriptorsSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -2435,7 +2437,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kPcDescriptorsCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2472,7 +2473,7 @@
: DeserializationCluster("PcDescriptors") {}
~PcDescriptorsDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -2484,8 +2485,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
const intptr_t length = d->ReadUnsigned();
PcDescriptorsPtr desc = static_cast<PcDescriptorsPtr>(d->Ref(id));
@@ -2501,7 +2502,8 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class CodeSourceMapSerializationCluster : public SerializationCluster {
public:
- CodeSourceMapSerializationCluster() : SerializationCluster("CodeSourceMap") {}
+ CodeSourceMapSerializationCluster()
+ : SerializationCluster("CodeSourceMap", kCodeSourceMapCid) {}
~CodeSourceMapSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -2510,7 +2512,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kCodeSourceMapCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2547,7 +2548,7 @@
: DeserializationCluster("CodeSourceMap") {}
~CodeSourceMapDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool is_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -2559,7 +2560,7 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool is_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
const intptr_t length = d->ReadUnsigned();
CodeSourceMapPtr map = static_cast<CodeSourceMapPtr>(d->Ref(id));
@@ -2576,7 +2577,7 @@
class CompressedStackMapsSerializationCluster : public SerializationCluster {
public:
CompressedStackMapsSerializationCluster()
- : SerializationCluster("CompressedStackMaps") {}
+ : SerializationCluster("CompressedStackMaps", kCompressedStackMapsCid) {}
~CompressedStackMapsSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -2585,7 +2586,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kCompressedStackMapsCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2625,7 +2625,7 @@
: DeserializationCluster("CompressedStackMaps") {}
~CompressedStackMapsDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool is_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -2637,7 +2637,7 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool is_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
const intptr_t flags_and_size = d->ReadUnsigned();
const intptr_t length =
@@ -2665,6 +2665,8 @@
intptr_t cid,
bool is_canonical)
: CanonicalSetSerializationCluster(
+ cid,
+ is_canonical,
is_canonical && IsStringClassId(cid),
ImageWriter::TagObjectTypeAsReadOnly(zone, type)),
zone_(zone),
@@ -2689,7 +2691,6 @@
void WriteAlloc(Serializer* s) {
const bool is_string_cluster = IsStringClassId(cid_);
- s->WriteCid(cid_);
intptr_t count = objects_.length();
s->WriteUnsigned(count);
@@ -2729,11 +2730,16 @@
class RODataDeserializationCluster
: public CanonicalSetDeserializationCluster<CanonicalStringSet> {
public:
- explicit RODataDeserializationCluster(bool is_root_unit, intptr_t cid)
- : CanonicalSetDeserializationCluster(is_root_unit, "ROData"), cid_(cid) {}
+ explicit RODataDeserializationCluster(bool is_canonical,
+ bool is_root_unit,
+ intptr_t cid)
+ : CanonicalSetDeserializationCluster(is_canonical,
+ is_root_unit,
+ "ROData"),
+ cid_(cid) {}
~RODataDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
intptr_t count = d->ReadUnsigned();
uint32_t running_offset = 0;
@@ -2743,14 +2749,16 @@
d->AssignRef(object);
}
stop_index_ = d->next_index();
- BuildCanonicalSetFromLayout(d, cid_ == kStringCid);
+ if (cid_ == kStringCid) {
+ BuildCanonicalSetFromLayout(d);
+ }
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
// No-op.
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (!table_.IsNull()) {
auto object_store = d->isolate_group()->object_store();
VerifyCanonicalSet(d, refs, Array::Handle(object_store->symbol_table()));
@@ -2758,7 +2766,7 @@
if (d->isolate_group() == Dart::vm_isolate_group()) {
Symbols::InitFromSnapshot(d->isolate_group());
}
- } else if (canonicalize) {
+ } else if (!primary && is_canonical()) {
FATAL("Cannot recanonicalize RO objects.");
}
}
@@ -2772,7 +2780,7 @@
class ExceptionHandlersSerializationCluster : public SerializationCluster {
public:
ExceptionHandlersSerializationCluster()
- : SerializationCluster("ExceptionHandlers") {}
+ : SerializationCluster("ExceptionHandlers", kExceptionHandlersCid) {}
~ExceptionHandlersSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -2783,7 +2791,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kExceptionHandlersCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2827,7 +2834,7 @@
: DeserializationCluster("ExceptionHandlers") {}
~ExceptionHandlersDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -2839,8 +2846,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
ExceptionHandlersPtr handlers =
static_cast<ExceptionHandlersPtr>(d->Ref(id));
@@ -2865,7 +2872,8 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class ContextSerializationCluster : public SerializationCluster {
public:
- ContextSerializationCluster() : SerializationCluster("Context") {}
+ ContextSerializationCluster()
+ : SerializationCluster("Context", kContextCid) {}
~ContextSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -2880,7 +2888,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kContextCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2917,7 +2924,7 @@
ContextDeserializationCluster() : DeserializationCluster("Context") {}
~ContextDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -2929,8 +2936,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
ContextPtr context = static_cast<ContextPtr>(d->Ref(id));
const intptr_t length = d->ReadUnsigned();
@@ -2948,7 +2955,8 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class ContextScopeSerializationCluster : public SerializationCluster {
public:
- ContextScopeSerializationCluster() : SerializationCluster("ContextScope") {}
+ ContextScopeSerializationCluster()
+ : SerializationCluster("ContextScope", kContextScopeCid) {}
~ContextScopeSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -2960,7 +2968,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kContextScopeCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -2997,7 +3004,7 @@
: DeserializationCluster("ContextScope") {}
~ContextScopeDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3009,8 +3016,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
ContextScopePtr scope = static_cast<ContextScopePtr>(d->Ref(id));
const intptr_t length = d->ReadUnsigned();
@@ -3028,6 +3035,7 @@
public:
UnlinkedCallSerializationCluster()
: SerializationCluster("UnlinkedCall",
+ kUnlinkedCallCid,
compiler::target::UnlinkedCall::InstanceSize()) {}
~UnlinkedCallSerializationCluster() {}
@@ -3038,7 +3046,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kUnlinkedCallCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3068,7 +3075,7 @@
: DeserializationCluster("UnlinkedCall") {}
~UnlinkedCallDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3079,8 +3086,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
UnlinkedCallPtr unlinked = static_cast<UnlinkedCallPtr>(d->Ref(id));
Deserializer::InitializeHeader(unlinked, kUnlinkedCallCid,
@@ -3096,6 +3103,7 @@
public:
ICDataSerializationCluster()
: SerializationCluster("ICData",
+ kICDataCid,
compiler::target::ICData::InstanceSize()) {}
~ICDataSerializationCluster() {}
@@ -3106,7 +3114,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kICDataCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3139,7 +3146,7 @@
ICDataDeserializationCluster() : DeserializationCluster("ICData") {}
~ICDataDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3149,8 +3156,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
ICDataPtr ic = static_cast<ICDataPtr>(d->Ref(id));
Deserializer::InitializeHeader(ic, kICDataCid, ICData::InstanceSize());
@@ -3167,6 +3174,7 @@
MegamorphicCacheSerializationCluster()
: SerializationCluster(
"MegamorphicCache",
+ kMegamorphicCacheCid,
compiler::target::MegamorphicCache::InstanceSize()) {}
~MegamorphicCacheSerializationCluster() {}
@@ -3177,7 +3185,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kMegamorphicCacheCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3207,7 +3214,7 @@
: DeserializationCluster("MegamorphicCache") {}
~MegamorphicCacheDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3218,8 +3225,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
MegamorphicCachePtr cache = static_cast<MegamorphicCachePtr>(d->Ref(id));
Deserializer::InitializeHeader(cache, kMegamorphicCacheCid,
@@ -3230,7 +3237,7 @@
}
#if defined(DART_PRECOMPILED_RUNTIME)
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (FLAG_use_bare_instructions) {
// By default, every megamorphic call site will load the target
// [Function] from the hash table and call indirectly via loading the
@@ -3255,6 +3262,7 @@
SubtypeTestCacheSerializationCluster()
: SerializationCluster(
"SubtypeTestCache",
+ kSubtypeTestCacheCid,
compiler::target::SubtypeTestCache::InstanceSize()) {}
~SubtypeTestCacheSerializationCluster() {}
@@ -3265,7 +3273,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kSubtypeTestCacheCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3294,7 +3301,7 @@
: DeserializationCluster("SubtypeTestCache") {}
~SubtypeTestCacheDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3305,8 +3312,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
SubtypeTestCachePtr cache = static_cast<SubtypeTestCachePtr>(d->Ref(id));
Deserializer::InitializeHeader(cache, kSubtypeTestCacheCid,
@@ -3321,6 +3328,7 @@
public:
LoadingUnitSerializationCluster()
: SerializationCluster("LoadingUnit",
+ kLoadingUnitCid,
compiler::target::LoadingUnit::InstanceSize()) {}
~LoadingUnitSerializationCluster() {}
@@ -3331,7 +3339,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kLoadingUnitCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3360,7 +3367,7 @@
LoadingUnitDeserializationCluster() : DeserializationCluster("LoadingUnit") {}
~LoadingUnitDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3371,8 +3378,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
LoadingUnitPtr unit = static_cast<LoadingUnitPtr>(d->Ref(id));
Deserializer::InitializeHeader(unit, kLoadingUnitCid,
@@ -3391,6 +3398,7 @@
public:
LanguageErrorSerializationCluster()
: SerializationCluster("LanguageError",
+ kLanguageErrorCid,
compiler::target::LanguageError::InstanceSize()) {}
~LanguageErrorSerializationCluster() {}
@@ -3401,7 +3409,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kLanguageErrorCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3433,7 +3440,7 @@
: DeserializationCluster("LanguageError") {}
~LanguageErrorDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3444,8 +3451,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
LanguageErrorPtr error = static_cast<LanguageErrorPtr>(d->Ref(id));
Deserializer::InitializeHeader(error, kLanguageErrorCid,
@@ -3464,6 +3471,7 @@
UnhandledExceptionSerializationCluster()
: SerializationCluster(
"UnhandledException",
+ kUnhandledExceptionCid,
compiler::target::UnhandledException::InstanceSize()) {}
~UnhandledExceptionSerializationCluster() {}
@@ -3474,7 +3482,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kUnhandledExceptionCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3503,7 +3510,7 @@
: DeserializationCluster("UnhandledException") {}
~UnhandledExceptionDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3514,8 +3521,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
UnhandledExceptionPtr exception =
static_cast<UnhandledExceptionPtr>(d->Ref(id));
@@ -3529,8 +3536,8 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class InstanceSerializationCluster : public SerializationCluster {
public:
- explicit InstanceSerializationCluster(intptr_t cid)
- : SerializationCluster("Instance"), cid_(cid) {
+ InstanceSerializationCluster(bool is_canonical, intptr_t cid)
+ : SerializationCluster("Instance", cid, kSizeVaries, is_canonical) {
ClassPtr cls = IsolateGroup::Current()->class_table()->At(cid);
host_next_field_offset_in_words_ =
cls->untag()->host_next_field_offset_in_words_;
@@ -3564,7 +3571,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(cid_);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
@@ -3610,7 +3616,6 @@
}
private:
- const intptr_t cid_;
intptr_t host_next_field_offset_in_words_;
intptr_t target_next_field_offset_in_words_;
intptr_t target_instance_size_in_words_;
@@ -3620,12 +3625,13 @@
class AbstractInstanceDeserializationCluster : public DeserializationCluster {
protected:
- explicit AbstractInstanceDeserializationCluster(const char* name)
- : DeserializationCluster(name) {}
+ explicit AbstractInstanceDeserializationCluster(const char* name,
+ bool is_canonical)
+ : DeserializationCluster(name, is_canonical) {}
public:
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
- if (canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
+ if (!primary && is_canonical()) {
SafepointMutexLocker ml(
d->isolate_group()->constant_canonicalization_mutex());
Instance& instance = Instance::Handle(d->zone());
@@ -3641,11 +3647,12 @@
class InstanceDeserializationCluster
: public AbstractInstanceDeserializationCluster {
public:
- explicit InstanceDeserializationCluster(intptr_t cid)
- : AbstractInstanceDeserializationCluster("Instance"), cid_(cid) {}
+ explicit InstanceDeserializationCluster(intptr_t cid, bool is_canonical)
+ : AbstractInstanceDeserializationCluster("Instance", is_canonical),
+ cid_(cid) {}
~InstanceDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3659,7 +3666,7 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
intptr_t next_field_offset = next_field_offset_in_words_ << kWordSizeLog2;
intptr_t instance_size =
Object::RoundedAllocationSize(instance_size_in_words_ * kWordSize);
@@ -3668,7 +3675,7 @@
for (intptr_t id = start_index_; id < stop_index_; id++) {
InstancePtr instance = static_cast<InstancePtr>(d->Ref(id));
Deserializer::InitializeHeader(instance, cid_, instance_size,
- stamp_canonical);
+ primary && is_canonical());
intptr_t offset = Instance::NextFieldOffset();
while (offset < next_field_offset) {
if (unboxed_fields_bitmap.Get(offset / kWordSize)) {
@@ -3704,6 +3711,7 @@
public:
LibraryPrefixSerializationCluster()
: SerializationCluster("LibraryPrefix",
+ kLibraryPrefixCid,
compiler::target::LibraryPrefix::InstanceSize()) {}
~LibraryPrefixSerializationCluster() {}
@@ -3714,7 +3722,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kLibraryPrefixCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -3745,7 +3752,7 @@
: DeserializationCluster("LibraryPrefix") {}
~LibraryPrefixDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3756,8 +3763,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
LibraryPrefixPtr prefix = static_cast<LibraryPrefixPtr>(d->Ref(id));
Deserializer::InitializeHeader(prefix, kLibraryPrefixCid,
@@ -3781,8 +3788,10 @@
TypePtr,
/*kAllCanonicalObjectsAreIncludedIntoSet=*/false> {
public:
- explicit TypeSerializationCluster(bool represents_canonical_set)
+ TypeSerializationCluster(bool is_canonical, bool represents_canonical_set)
: CanonicalSetSerializationCluster(
+ kTypeCid,
+ is_canonical,
represents_canonical_set,
"Type",
compiler::target::Type::InstanceSize()) {}
@@ -3806,7 +3815,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kTypeCid);
intptr_t count = objects_.length();
s->WriteUnsigned(count);
ReorderObjects(s);
@@ -3869,11 +3877,12 @@
CanonicalTypeSet,
/*kAllCanonicalObjectsAreIncludedIntoSet=*/false> {
public:
- explicit TypeDeserializationCluster(bool is_root_unit)
- : CanonicalSetDeserializationCluster(is_root_unit, "Type") {}
+ explicit TypeDeserializationCluster(bool is_canonical, bool is_root_unit)
+ : CanonicalSetDeserializationCluster(is_canonical, is_root_unit, "Type") {
+ }
~TypeDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -3882,14 +3891,14 @@
d->AssignRef(object);
}
stop_index_ = d->next_index();
- BuildCanonicalSetFromLayout(d, stamp_canonical);
+ BuildCanonicalSetFromLayout(d);
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
TypePtr type = static_cast<TypePtr>(d->Ref(id));
Deserializer::InitializeHeader(type, kTypeCid, Type::InstanceSize(),
- stamp_canonical);
+ primary && is_canonical());
ReadFromTo(type);
const uint8_t combined = d->Read<uint8_t>();
type->untag()->type_state_ = combined >> kNullabilityBitSize;
@@ -3897,13 +3906,13 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (!table_.IsNull()) {
auto object_store = d->isolate_group()->object_store();
VerifyCanonicalSet(d, refs,
Array::Handle(object_store->canonical_types()));
object_store->set_canonical_types(table_);
- } else if (canonicalize) {
+ } else if (!primary && is_canonical()) {
AbstractType& type = AbstractType::Handle(d->zone());
for (intptr_t i = start_index_; i < stop_index_; i++) {
type ^= refs.At(i);
@@ -3937,8 +3946,11 @@
FunctionType,
FunctionTypePtr> {
public:
- explicit FunctionTypeSerializationCluster(bool represents_canonical_set)
+ explicit FunctionTypeSerializationCluster(bool is_canonical,
+ bool represents_canonical_set)
: CanonicalSetSerializationCluster(
+ kFunctionTypeCid,
+ is_canonical,
represents_canonical_set,
"FunctionType",
compiler::target::FunctionType::InstanceSize()) {}
@@ -3951,7 +3963,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kFunctionTypeCid);
intptr_t count = objects_.length();
s->WriteUnsigned(count);
ReorderObjects(s);
@@ -3995,11 +4006,14 @@
class FunctionTypeDeserializationCluster
: public CanonicalSetDeserializationCluster<CanonicalFunctionTypeSet> {
public:
- explicit FunctionTypeDeserializationCluster(bool is_root_unit)
- : CanonicalSetDeserializationCluster(is_root_unit, "FunctionType") {}
+ explicit FunctionTypeDeserializationCluster(bool is_canonical,
+ bool is_root_unit)
+ : CanonicalSetDeserializationCluster(is_canonical,
+ is_root_unit,
+ "FunctionType") {}
~FunctionTypeDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4009,15 +4023,15 @@
d->AssignRef(object);
}
stop_index_ = d->next_index();
- BuildCanonicalSetFromLayout(d, stamp_canonical);
+ BuildCanonicalSetFromLayout(d);
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
FunctionTypePtr type = static_cast<FunctionTypePtr>(d->Ref(id));
Deserializer::InitializeHeader(type, kFunctionTypeCid,
FunctionType::InstanceSize(),
- stamp_canonical);
+ primary && is_canonical());
ReadFromTo(type);
const uint8_t combined = d->Read<uint8_t>();
type->untag()->type_state_ = combined >> kNullabilityBitSize;
@@ -4026,13 +4040,13 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (!table_.IsNull()) {
auto object_store = d->isolate_group()->object_store();
VerifyCanonicalSet(
d, refs, Array::Handle(object_store->canonical_function_types()));
object_store->set_canonical_function_types(table_);
- } else if (canonicalize) {
+ } else if (!primary && is_canonical()) {
AbstractType& type = AbstractType::Handle(d->zone());
for (intptr_t i = start_index_; i < stop_index_; i++) {
type ^= refs.At(i);
@@ -4065,6 +4079,7 @@
public:
TypeRefSerializationCluster()
: SerializationCluster("TypeRef",
+ kTypeRefCid,
compiler::target::TypeRef::InstanceSize()) {}
~TypeRefSerializationCluster() {}
@@ -4075,7 +4090,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kTypeRefCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -4103,7 +4117,7 @@
TypeRefDeserializationCluster() : DeserializationCluster("TypeRef") {}
~TypeRefDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4113,17 +4127,17 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
TypeRefPtr type = static_cast<TypeRefPtr>(d->Ref(id));
Deserializer::InitializeHeader(type, kTypeRefCid, TypeRef::InstanceSize(),
- stamp_canonical);
+ primary && is_canonical());
ReadFromTo(type);
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
- if (canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
+ if (!primary && is_canonical()) {
AbstractType& type = AbstractType::Handle(d->zone());
for (intptr_t i = start_index_; i < stop_index_; i++) {
type ^= refs.At(i);
@@ -4158,9 +4172,11 @@
TypeParameter,
TypeParameterPtr> {
public:
- explicit TypeParameterSerializationCluster(
- bool cluster_represents_canonical_set)
+ TypeParameterSerializationCluster(bool is_canonical,
+ bool cluster_represents_canonical_set)
: CanonicalSetSerializationCluster(
+ kTypeParameterCid,
+ is_canonical,
cluster_represents_canonical_set,
"TypeParameter",
compiler::target::TypeParameter::InstanceSize()) {}
@@ -4174,7 +4190,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kTypeParameterCid);
intptr_t count = objects_.length();
s->WriteUnsigned(count);
ReorderObjects(s);
@@ -4216,11 +4231,14 @@
class TypeParameterDeserializationCluster
: public CanonicalSetDeserializationCluster<CanonicalTypeParameterSet> {
public:
- explicit TypeParameterDeserializationCluster(bool is_root_unit)
- : CanonicalSetDeserializationCluster(is_root_unit, "TypeParameter") {}
+ explicit TypeParameterDeserializationCluster(bool is_canonical,
+ bool is_root_unit)
+ : CanonicalSetDeserializationCluster(is_canonical,
+ is_root_unit,
+ "TypeParameter") {}
~TypeParameterDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4229,15 +4247,15 @@
AllocateUninitialized(old_space, TypeParameter::InstanceSize()));
}
stop_index_ = d->next_index();
- BuildCanonicalSetFromLayout(d, stamp_canonical);
+ BuildCanonicalSetFromLayout(d);
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
TypeParameterPtr type = static_cast<TypeParameterPtr>(d->Ref(id));
Deserializer::InitializeHeader(type, kTypeParameterCid,
TypeParameter::InstanceSize(),
- stamp_canonical);
+ primary && is_canonical());
ReadFromTo(type);
type->untag()->parameterized_class_id_ = d->Read<int32_t>();
type->untag()->base_ = d->Read<uint16_t>();
@@ -4248,13 +4266,13 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
if (!table_.IsNull()) {
auto object_store = d->isolate_group()->object_store();
VerifyCanonicalSet(
d, refs, Array::Handle(object_store->canonical_type_parameters()));
object_store->set_canonical_type_parameters(table_);
- } else if (canonicalize) {
+ } else if (!primary && is_canonical()) {
TypeParameter& type_param = TypeParameter::Handle(d->zone());
for (intptr_t i = start_index_; i < stop_index_; i++) {
type_param ^= refs.At(i);
@@ -4286,9 +4304,11 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class ClosureSerializationCluster : public SerializationCluster {
public:
- ClosureSerializationCluster()
+ explicit ClosureSerializationCluster(bool is_canonical)
: SerializationCluster("Closure",
- compiler::target::Closure::InstanceSize()) {}
+ kClosureCid,
+ compiler::target::Closure::InstanceSize(),
+ is_canonical) {}
~ClosureSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -4298,7 +4318,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kClosureCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -4324,11 +4343,11 @@
class ClosureDeserializationCluster
: public AbstractInstanceDeserializationCluster {
public:
- ClosureDeserializationCluster()
- : AbstractInstanceDeserializationCluster("Closure") {}
+ explicit ClosureDeserializationCluster(bool is_canonical)
+ : AbstractInstanceDeserializationCluster("Closure", is_canonical) {}
~ClosureDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4338,11 +4357,12 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
ClosurePtr closure = static_cast<ClosurePtr>(d->Ref(id));
Deserializer::InitializeHeader(closure, kClosureCid,
- Closure::InstanceSize(), stamp_canonical);
+ Closure::InstanceSize(),
+ primary && is_canonical());
ReadFromTo(closure);
}
}
@@ -4351,8 +4371,8 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class MintSerializationCluster : public SerializationCluster {
public:
- MintSerializationCluster()
- : SerializationCluster("int", compiler::target::Mint::InstanceSize()) {}
+ explicit MintSerializationCluster(bool is_canonical)
+ : SerializationCluster("int", kMintCid, kSizeVaries, is_canonical) {}
~MintSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -4366,20 +4386,26 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kMintCid);
-
s->WriteUnsigned(smis_.length() + mints_.length());
for (intptr_t i = 0; i < smis_.length(); i++) {
SmiPtr smi = smis_[i];
s->AssignRef(smi);
AutoTraceObject(smi);
- s->Write<int64_t>(Smi::Value(smi));
+ const int64_t value = Smi::Value(smi);
+ s->Write<int64_t>(value);
+ if (!Smi::IsValid(value)) {
+ // This Smi will become a Mint when loaded.
+ target_memory_size_ += compiler::target::Mint::InstanceSize();
+ }
}
for (intptr_t i = 0; i < mints_.length(); i++) {
MintPtr mint = mints_[i];
s->AssignRef(mint);
AutoTraceObject(mint);
s->Write<int64_t>(mint->untag()->value_);
+ // All Mints on the host should be Mints on the target.
+ ASSERT(!Smi::IsValid(mint->untag()->value_));
+ target_memory_size_ += compiler::target::Mint::InstanceSize();
}
}
@@ -4393,10 +4419,11 @@
class MintDeserializationCluster : public DeserializationCluster {
public:
- MintDeserializationCluster() : DeserializationCluster("int") {}
+ explicit MintDeserializationCluster(bool is_canonical)
+ : DeserializationCluster("int", is_canonical) {}
~MintDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
PageSpace* old_space = d->heap()->old_space();
start_index_ = d->next_index();
@@ -4409,7 +4436,7 @@
MintPtr mint = static_cast<MintPtr>(
AllocateUninitialized(old_space, Mint::InstanceSize()));
Deserializer::InitializeHeader(mint, kMintCid, Mint::InstanceSize(),
- stamp_canonical);
+ is_canonical());
mint->untag()->value_ = value;
d->AssignRef(mint);
}
@@ -4417,10 +4444,10 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {}
+ void ReadFill(Deserializer* d, bool primary) {}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
- if (canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
+ if (!primary && is_canonical()) {
const Class& mint_cls = Class::Handle(
d->zone(), d->isolate_group()->object_store()->mint_class());
Object& number = Object::Handle(d->zone());
@@ -4446,9 +4473,11 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class DoubleSerializationCluster : public SerializationCluster {
public:
- DoubleSerializationCluster()
+ explicit DoubleSerializationCluster(bool is_canonical)
: SerializationCluster("double",
- compiler::target::Double::InstanceSize()) {}
+ kDoubleCid,
+ compiler::target::Double::InstanceSize(),
+ is_canonical) {}
~DoubleSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -4457,7 +4486,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kDoubleCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -4482,10 +4510,11 @@
class DoubleDeserializationCluster : public DeserializationCluster {
public:
- DoubleDeserializationCluster() : DeserializationCluster("double") {}
+ explicit DoubleDeserializationCluster(bool is_canonical)
+ : DeserializationCluster("double", is_canonical) {}
~DoubleDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4495,17 +4524,17 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
DoublePtr dbl = static_cast<DoublePtr>(d->Ref(id));
Deserializer::InitializeHeader(dbl, kDoubleCid, Double::InstanceSize(),
- stamp_canonical);
+ primary && is_canonical());
dbl->untag()->value_ = d->Read<double>();
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
- if (canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
+ if (!primary && is_canonical()) {
auto Z = d->zone();
auto isolate_group = d->isolate_group();
const Class& cls =
@@ -4533,6 +4562,7 @@
GrowableObjectArraySerializationCluster()
: SerializationCluster(
"GrowableObjectArray",
+ kGrowableObjectArrayCid,
compiler::target::GrowableObjectArray::InstanceSize()) {}
~GrowableObjectArraySerializationCluster() {}
@@ -4543,7 +4573,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kGrowableObjectArrayCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -4573,7 +4602,7 @@
: DeserializationCluster("GrowableObjectArray") {}
~GrowableObjectArrayDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4584,13 +4613,12 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
GrowableObjectArrayPtr list =
static_cast<GrowableObjectArrayPtr>(d->Ref(id));
Deserializer::InitializeHeader(list, kGrowableObjectArrayCid,
- GrowableObjectArray::InstanceSize(),
- stamp_canonical);
+ GrowableObjectArray::InstanceSize());
ReadFromTo(list);
}
}
@@ -4600,7 +4628,7 @@
class TypedDataSerializationCluster : public SerializationCluster {
public:
explicit TypedDataSerializationCluster(intptr_t cid)
- : SerializationCluster("TypedData"), cid_(cid) {}
+ : SerializationCluster("TypedData", cid) {}
~TypedDataSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -4609,7 +4637,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(cid_);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
const intptr_t element_size = TypedData::ElementSizeInBytes(cid_);
@@ -4638,7 +4665,6 @@
}
private:
- const intptr_t cid_;
GrowableArray<TypedDataPtr> objects_;
};
#endif // !DART_PRECOMPILED_RUNTIME
@@ -4649,7 +4675,7 @@
: DeserializationCluster("TypedData"), cid_(cid) {}
~TypedDataDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4662,8 +4688,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
intptr_t element_size = TypedData::ElementSizeInBytes(cid_);
for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ -4671,8 +4697,7 @@
const intptr_t length = d->ReadUnsigned();
const intptr_t length_in_bytes = length * element_size;
Deserializer::InitializeHeader(data, cid_,
- TypedData::InstanceSize(length_in_bytes),
- stamp_canonical);
+ TypedData::InstanceSize(length_in_bytes));
data->untag()->length_ = Smi::New(length);
data->untag()->RecomputeDataField();
uint8_t* cdata = reinterpret_cast<uint8_t*>(data->untag()->data());
@@ -4689,8 +4714,8 @@
public:
explicit TypedDataViewSerializationCluster(intptr_t cid)
: SerializationCluster("TypedDataView",
- compiler::target::TypedDataView::InstanceSize()),
- cid_(cid) {}
+ cid,
+ compiler::target::TypedDataView::InstanceSize()) {}
~TypedDataViewSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -4702,7 +4727,6 @@
void WriteAlloc(Serializer* s) {
const intptr_t count = objects_.length();
- s->WriteCid(cid_);
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
TypedDataViewPtr view = objects_[i];
@@ -4720,7 +4744,6 @@
}
private:
- const intptr_t cid_;
GrowableArray<TypedDataViewPtr> objects_;
};
#endif // !DART_PRECOMPILED_RUNTIME
@@ -4731,7 +4754,7 @@
: DeserializationCluster("TypedDataView"), cid_(cid) {}
~TypedDataViewDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4742,8 +4765,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
TypedDataViewPtr view = static_cast<TypedDataViewPtr>(d->Ref(id));
Deserializer::InitializeHeader(view, cid_, TypedDataView::InstanceSize());
@@ -4751,8 +4774,8 @@
}
}
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
- ASSERT(!canonicalize);
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
+ ASSERT(primary || !is_canonical());
auto& view = TypedDataView::Handle(d->zone());
for (intptr_t id = start_index_; id < stop_index_; id++) {
view ^= refs.At(id);
@@ -4770,8 +4793,8 @@
explicit ExternalTypedDataSerializationCluster(intptr_t cid)
: SerializationCluster(
"ExternalTypedData",
- compiler::target::ExternalTypedData::InstanceSize()),
- cid_(cid) {}
+ cid,
+ compiler::target::ExternalTypedData::InstanceSize()) {}
~ExternalTypedDataSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -4780,7 +4803,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(cid_);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -4804,7 +4826,6 @@
}
private:
- const intptr_t cid_;
GrowableArray<ExternalTypedDataPtr> objects_;
};
#endif // !DART_PRECOMPILED_RUNTIME
@@ -4815,7 +4836,7 @@
: DeserializationCluster("ExternalTypedData"), cid_(cid) {}
~ExternalTypedDataDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4826,8 +4847,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
intptr_t element_size = ExternalTypedData::ElementSizeInBytes(cid_);
for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ -4852,6 +4873,7 @@
public:
StackTraceSerializationCluster()
: SerializationCluster("StackTrace",
+ kStackTraceCid,
compiler::target::StackTrace::InstanceSize()) {}
~StackTraceSerializationCluster() {}
@@ -4862,7 +4884,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kStackTraceCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -4890,7 +4911,7 @@
StackTraceDeserializationCluster() : DeserializationCluster("StackTrace") {}
~StackTraceDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4901,8 +4922,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
StackTracePtr trace = static_cast<StackTracePtr>(d->Ref(id));
Deserializer::InitializeHeader(trace, kStackTraceCid,
@@ -4917,6 +4938,7 @@
public:
RegExpSerializationCluster()
: SerializationCluster("RegExp",
+ kRegExpCid,
compiler::target::RegExp::InstanceSize()) {}
~RegExpSerializationCluster() {}
@@ -4927,7 +4949,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kRegExpCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -4958,7 +4979,7 @@
RegExpDeserializationCluster() : DeserializationCluster("RegExp") {}
~RegExpDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -4968,8 +4989,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
RegExpPtr regexp = static_cast<RegExpPtr>(d->Ref(id));
Deserializer::InitializeHeader(regexp, kRegExpCid,
@@ -4987,6 +5008,7 @@
public:
WeakPropertySerializationCluster()
: SerializationCluster("WeakProperty",
+ kWeakPropertyCid,
compiler::target::WeakProperty::InstanceSize()) {}
~WeakPropertySerializationCluster() {}
@@ -5005,7 +5027,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kWeakPropertyCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -5041,7 +5062,7 @@
: DeserializationCluster("WeakProperty") {}
~WeakPropertyDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -5052,8 +5073,8 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
- ASSERT(!stamp_canonical); // Never canonical.
+ void ReadFill(Deserializer* d, bool primary) {
+ ASSERT(!is_canonical()); // Never canonical.
for (intptr_t id = start_index_; id < stop_index_; id++) {
WeakPropertyPtr property = static_cast<WeakPropertyPtr>(d->Ref(id));
Deserializer::InitializeHeader(property, kWeakPropertyCid,
@@ -5069,6 +5090,7 @@
public:
LinkedHashMapSerializationCluster()
: SerializationCluster("LinkedHashMap",
+ kLinkedHashMapCid,
compiler::target::LinkedHashMap::InstanceSize()) {}
~LinkedHashMapSerializationCluster() {}
@@ -5092,7 +5114,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kLinkedHashMapCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -5137,11 +5158,11 @@
class LinkedHashMapDeserializationCluster
: public AbstractInstanceDeserializationCluster {
public:
- LinkedHashMapDeserializationCluster()
- : AbstractInstanceDeserializationCluster("LinkedHashMap") {}
+ explicit LinkedHashMapDeserializationCluster(bool is_canonical)
+ : AbstractInstanceDeserializationCluster("LinkedHashMap", is_canonical) {}
~LinkedHashMapDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -5152,14 +5173,14 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
PageSpace* old_space = d->heap()->old_space();
for (intptr_t id = start_index_; id < stop_index_; id++) {
LinkedHashMapPtr map = static_cast<LinkedHashMapPtr>(d->Ref(id));
Deserializer::InitializeHeader(map, kLinkedHashMapCid,
LinkedHashMap::InstanceSize(),
- stamp_canonical);
+ primary && is_canonical());
map->untag()->type_arguments_ =
static_cast<TypeArgumentsPtr>(d->ReadRef());
@@ -5195,8 +5216,8 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class ArraySerializationCluster : public SerializationCluster {
public:
- explicit ArraySerializationCluster(intptr_t cid)
- : SerializationCluster("Array"), cid_(cid) {}
+ ArraySerializationCluster(bool is_canonical, intptr_t cid)
+ : SerializationCluster("Array", cid, kSizeVaries, is_canonical) {}
~ArraySerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -5211,7 +5232,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(cid_);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -5239,7 +5259,6 @@
}
private:
- intptr_t cid_;
GrowableArray<ArrayPtr> objects_;
};
#endif // !DART_PRECOMPILED_RUNTIME
@@ -5247,11 +5266,12 @@
class ArrayDeserializationCluster
: public AbstractInstanceDeserializationCluster {
public:
- explicit ArrayDeserializationCluster(intptr_t cid)
- : AbstractInstanceDeserializationCluster("Array"), cid_(cid) {}
+ explicit ArrayDeserializationCluster(bool is_canonical, intptr_t cid)
+ : AbstractInstanceDeserializationCluster("Array", is_canonical),
+ cid_(cid) {}
~ArrayDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -5263,12 +5283,12 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
ArrayPtr array = static_cast<ArrayPtr>(d->Ref(id));
const intptr_t length = d->ReadUnsigned();
Deserializer::InitializeHeader(array, cid_, Array::InstanceSize(length),
- stamp_canonical);
+ primary && is_canonical());
array->untag()->type_arguments_ =
static_cast<TypeArgumentsPtr>(d->ReadRef());
array->untag()->length_ = Smi::New(length);
@@ -5285,7 +5305,11 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class OneByteStringSerializationCluster : public SerializationCluster {
public:
- OneByteStringSerializationCluster() : SerializationCluster("OneByteString") {}
+ explicit OneByteStringSerializationCluster(bool is_canonical)
+ : SerializationCluster("OneByteString",
+ kOneByteStringCid,
+ kSizeVaries,
+ is_canonical) {}
~OneByteStringSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -5294,7 +5318,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kOneByteStringCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -5327,12 +5350,12 @@
class StringDeserializationCluster : public DeserializationCluster {
protected:
- explicit StringDeserializationCluster(const char* name)
- : DeserializationCluster(name) {}
+ StringDeserializationCluster(const char* name, bool is_canonical)
+ : DeserializationCluster(name, is_canonical) {}
public:
- void PostLoad(Deserializer* d, const Array& refs, bool canonicalize) {
- if (canonicalize) {
+ void PostLoad(Deserializer* d, const Array& refs, bool primary) {
+ if (!primary && is_canonical()) {
auto Z = d->zone();
auto isolate_group = d->isolate_group();
SafepointMutexLocker ml(isolate_group->constant_canonicalization_mutex());
@@ -5357,11 +5380,11 @@
class OneByteStringDeserializationCluster
: public StringDeserializationCluster {
public:
- OneByteStringDeserializationCluster()
- : StringDeserializationCluster("OneByteString") {}
+ explicit OneByteStringDeserializationCluster(bool is_canonical)
+ : StringDeserializationCluster("OneByteString", is_canonical) {}
~OneByteStringDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -5373,13 +5396,13 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
OneByteStringPtr str = static_cast<OneByteStringPtr>(d->Ref(id));
const intptr_t length = d->ReadUnsigned();
Deserializer::InitializeHeader(str, kOneByteStringCid,
OneByteString::InstanceSize(length),
- stamp_canonical);
+ primary && is_canonical());
str->untag()->length_ = Smi::New(length);
StringHasher hasher;
for (intptr_t j = 0; j < length; j++) {
@@ -5395,7 +5418,11 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
class TwoByteStringSerializationCluster : public SerializationCluster {
public:
- TwoByteStringSerializationCluster() : SerializationCluster("TwoByteString") {}
+ explicit TwoByteStringSerializationCluster(bool is_canonical)
+ : SerializationCluster("TwoByteString",
+ kTwoByteStringCid,
+ kSizeVaries,
+ is_canonical) {}
~TwoByteStringSerializationCluster() {}
void Trace(Serializer* s, ObjectPtr object) {
@@ -5404,7 +5431,6 @@
}
void WriteAlloc(Serializer* s) {
- s->WriteCid(kTwoByteStringCid);
const intptr_t count = objects_.length();
s->WriteUnsigned(count);
for (intptr_t i = 0; i < count; i++) {
@@ -5439,11 +5465,11 @@
class TwoByteStringDeserializationCluster
: public StringDeserializationCluster {
public:
- TwoByteStringDeserializationCluster()
- : StringDeserializationCluster("TwoByteString") {}
+ explicit TwoByteStringDeserializationCluster(bool is_canonical)
+ : StringDeserializationCluster("TwoByteString", is_canonical) {}
~TwoByteStringDeserializationCluster() {}
- void ReadAlloc(Deserializer* d, bool stamp_canonical) {
+ void ReadAlloc(Deserializer* d) {
start_index_ = d->next_index();
PageSpace* old_space = d->heap()->old_space();
const intptr_t count = d->ReadUnsigned();
@@ -5455,13 +5481,13 @@
stop_index_ = d->next_index();
}
- void ReadFill(Deserializer* d, bool stamp_canonical) {
+ void ReadFill(Deserializer* d, bool primary) {
for (intptr_t id = start_index_; id < stop_index_; id++) {
TwoByteStringPtr str = static_cast<TwoByteStringPtr>(d->Ref(id));
const intptr_t length = d->ReadUnsigned();
Deserializer::InitializeHeader(str, kTwoByteStringCid,
TwoByteString::InstanceSize(length),
- stamp_canonical);
+ primary && is_canonical());
str->untag()->length_ = Smi::New(length);
StringHasher hasher;
for (intptr_t j = 0; j < length; j++) {
@@ -5482,7 +5508,7 @@
intptr_t num_objects,
intptr_t size,
intptr_t target_memory_size = 0)
- : SerializationCluster(name) {
+ : SerializationCluster(name, -1) {
num_objects_ = num_objects;
size_ = size;
target_memory_size_ = target_memory_size;
@@ -6470,7 +6496,7 @@
Zone* Z = zone_;
if (cid >= kNumPredefinedCids || cid == kInstanceCid) {
Push(isolate_group()->class_table()->At(cid));
- return new (Z) InstanceSerializationCluster(cid);
+ return new (Z) InstanceSerializationCluster(is_canonical, cid);
}
if (IsTypedDataViewClassId(cid)) {
return new (Z) TypedDataViewSerializationCluster(cid);
@@ -6505,8 +6531,8 @@
case kClassCid:
return new (Z) ClassSerializationCluster(num_cids_ + num_tlc_cids_);
case kTypeArgumentsCid:
- return new (Z)
- TypeArgumentsSerializationCluster(cluster_represents_canonical_set);
+ return new (Z) TypeArgumentsSerializationCluster(
+ is_canonical, cluster_represents_canonical_set);
case kPatchClassCid:
return new (Z) PatchClassSerializationCluster();
case kFunctionCid:
@@ -6558,21 +6584,22 @@
case kLibraryPrefixCid:
return new (Z) LibraryPrefixSerializationCluster();
case kTypeCid:
- return new (Z) TypeSerializationCluster(cluster_represents_canonical_set);
+ return new (Z) TypeSerializationCluster(is_canonical,
+ cluster_represents_canonical_set);
case kFunctionTypeCid:
- return new (Z)
- FunctionTypeSerializationCluster(cluster_represents_canonical_set);
+ return new (Z) FunctionTypeSerializationCluster(
+ is_canonical, cluster_represents_canonical_set);
case kTypeRefCid:
return new (Z) TypeRefSerializationCluster();
case kTypeParameterCid:
- return new (Z)
- TypeParameterSerializationCluster(cluster_represents_canonical_set);
+ return new (Z) TypeParameterSerializationCluster(
+ is_canonical, cluster_represents_canonical_set);
case kClosureCid:
- return new (Z) ClosureSerializationCluster();
+ return new (Z) ClosureSerializationCluster(is_canonical);
case kMintCid:
- return new (Z) MintSerializationCluster();
+ return new (Z) MintSerializationCluster(is_canonical);
case kDoubleCid:
- return new (Z) DoubleSerializationCluster();
+ return new (Z) DoubleSerializationCluster(is_canonical);
case kGrowableObjectArrayCid:
return new (Z) GrowableObjectArraySerializationCluster();
case kStackTraceCid:
@@ -6584,13 +6611,14 @@
case kLinkedHashMapCid:
return new (Z) LinkedHashMapSerializationCluster();
case kArrayCid:
- return new (Z) ArraySerializationCluster(kArrayCid);
+ return new (Z) ArraySerializationCluster(is_canonical, kArrayCid);
case kImmutableArrayCid:
- return new (Z) ArraySerializationCluster(kImmutableArrayCid);
+ return new (Z)
+ ArraySerializationCluster(is_canonical, kImmutableArrayCid);
case kOneByteStringCid:
- return new (Z) OneByteStringSerializationCluster();
+ return new (Z) OneByteStringSerializationCluster(is_canonical);
case kTwoByteStringCid:
- return new (Z) TwoByteStringSerializationCluster();
+ return new (Z) TwoByteStringSerializationCluster(is_canonical);
case kWeakSerializationReferenceCid:
#if defined(DART_PRECOMPILER)
ASSERT(kind_ == Snapshot::kFullAOT);
@@ -6631,17 +6659,14 @@
intptr_t Serializer::PrepareInstructions() {
if (!Snapshot::IncludesCode(kind())) return 0;
- CodeSerializationCluster* cluster =
- static_cast<CodeSerializationCluster*>(clusters_by_cid_[kCodeCid]);
-
// Code objects that have identical/duplicate instructions must be adjacent in
// the order that Code objects are written because the encoding of the
// reference from the Code to the Instructions assumes monotonically
// increasing offsets as part of a delta encoding. Also the code order table
// that allows for mapping return addresses back to Code objects depends on
// this sorting.
- if (cluster != nullptr) {
- CodeSerializationCluster::Sort(cluster->objects());
+ if (code_cluster_ != nullptr) {
+ CodeSerializationCluster::Sort(code_cluster_->objects());
}
if ((loading_units_ != nullptr) &&
(current_loading_unit_id_ == LoadingUnit::kRootId)) {
@@ -6649,8 +6674,9 @@
i++) {
auto unit_objects = loading_units_->At(i)->deferred_objects();
CodeSerializationCluster::Sort(unit_objects);
+ ASSERT(unit_objects->length() == 0 || code_cluster_ != nullptr);
for (intptr_t j = 0; j < unit_objects->length(); j++) {
- cluster->deferred_objects()->Add(unit_objects->At(j)->ptr());
+ code_cluster_->deferred_objects()->Add(unit_objects->At(j)->ptr());
}
}
}
@@ -6664,8 +6690,8 @@
// instructions are now written by UnitSerializationRoots. This order needs
// to be known to finalize bare-instructions-mode's PC-relative calls.
GrowableArray<CodePtr> code_objects;
- if (cluster != nullptr) {
- auto in = cluster->objects();
+ if (code_cluster_ != nullptr) {
+ auto in = code_cluster_->objects();
for (intptr_t i = 0; i < in->length(); i++) {
code_objects.Add(in->At(i));
}
@@ -6817,6 +6843,12 @@
}
SerializationCluster* cluster = *cluster_ref;
ASSERT(cluster != nullptr);
+ if (cluster->is_canonical() != is_canonical) {
+ FATAL("cluster for %s (cid %" Pd ") %s as canonical, but %s",
+ cluster->name(), cid,
+ cluster->is_canonical() ? "marked" : "not marked",
+ is_canonical ? "should be" : "should not be");
+ }
#if defined(SNAPSHOT_BACKTRACE)
current_parent_ = object;
@@ -6939,17 +6971,22 @@
// Now that we have computed the reachability fixpoint, we remove the
// count of now-reachable WSRs as they are not actually serialized.
num_written_objects_ -= cluster->Count(this);
+ // We don't need to write this cluster, so remove it from consideration.
+ clusters_by_cid_[kWeakSerializationReferenceCid] = nullptr;
}
+ ASSERT(clusters_by_cid_[kWeakSerializationReferenceCid] == nullptr);
#endif
- GrowableArray<SerializationCluster*> canonical_clusters;
+ code_cluster_ = CID_CLUSTER(Code);
+
+ GrowableArray<SerializationCluster*> clusters;
// The order that PostLoad runs matters for some classes because of
// assumptions during canonicalization of some classes about what is already
// canonical. Explicitly place these clusters first, then add the rest
// ordered by class id.
#define ADD_NEXT(cid) \
- if (canonical_clusters_by_cid_[cid] != nullptr) { \
- canonical_clusters.Add(canonical_clusters_by_cid_[cid]); \
+ if (auto const cluster = canonical_clusters_by_cid_[cid]) { \
+ clusters.Add(cluster); \
canonical_clusters_by_cid_[cid] = nullptr; \
}
ADD_NEXT(kOneByteStringCid)
@@ -6961,28 +6998,31 @@
ADD_NEXT(kTypeArgumentsCid)
ADD_NEXT(kClosureCid)
#undef ADD_NEXT
+ const intptr_t out_of_order_clusters = clusters.length();
for (intptr_t cid = 0; cid < num_cids_; cid++) {
- if (canonical_clusters_by_cid_[cid] != nullptr) {
- canonical_clusters.Add(canonical_clusters_by_cid_[cid]);
+ if (auto const cluster = canonical_clusters_by_cid_[cid]) {
+ clusters.Add(cluster);
}
}
- GrowableArray<SerializationCluster*> clusters;
+ // Put these back so they'll show up in PrintSnapshotSizes.
+ for (intptr_t i = 0; i < out_of_order_clusters; i++) {
+ auto const cluster = clusters.At(i);
+ canonical_clusters_by_cid_[cluster->cid()] = cluster;
+ }
// Code cluster should be deserialized before Function as
// FunctionDeserializationCluster::ReadFill uses instructions table
// which is filled in CodeDeserializationCluster::ReadFill.
- if (clusters_by_cid_[kCodeCid] != nullptr) {
- clusters.Add(clusters_by_cid_[kCodeCid]);
+ if (auto const cluster = clusters_by_cid_[kCodeCid]) {
+ clusters.Add(cluster);
+ clusters_by_cid_[kCodeCid] = nullptr;
}
for (intptr_t cid = 0; cid < num_cids_; cid++) {
- // We don't actually have any WSR objects, references to them are replaced
- // either with the target or replacement.
- if (cid == kWeakSerializationReferenceCid) continue;
- // The code serialization cluster is already handled above.
- if (cid == kCodeCid) continue;
- if (clusters_by_cid_[cid] != nullptr) {
+ if (auto const cluster = clusters_by_cid_[cid]) {
clusters.Add(clusters_by_cid_[cid]);
}
}
+ // Put this back so it'll show up in PrintSnapshotSizes if present.
+ clusters_by_cid_[kCodeCid] = code_cluster_;
instructions_table_len_ = PrepareInstructions();
@@ -6995,7 +7035,6 @@
WriteUnsigned(num_base_objects_);
WriteUnsigned(num_objects);
- WriteUnsigned(canonical_clusters.length());
WriteUnsigned(clusters.length());
// TODO(dartbug.com/36097): Not every snapshot carries the field table.
if (current_loading_unit_id_ <= LoadingUnit::kRootId) {
@@ -7007,13 +7046,6 @@
(FLAG_precompiled_mode && FLAG_use_bare_instructions));
WriteUnsigned(instructions_table_len_);
- for (SerializationCluster* cluster : canonical_clusters) {
- cluster->WriteAndMeasureAlloc(this);
- bytes_heap_allocated_ += cluster->target_memory_size();
-#if defined(DEBUG)
- Write<int32_t>(next_ref_index_);
-#endif
- }
for (SerializationCluster* cluster : clusters) {
cluster->WriteAndMeasureAlloc(this);
bytes_heap_allocated_ += cluster->target_memory_size();
@@ -7027,12 +7059,6 @@
// And recorded them all in [objects_].
ASSERT(objects_->length() == num_objects);
- for (SerializationCluster* cluster : canonical_clusters) {
- cluster->WriteAndMeasureFill(this);
-#if defined(DEBUG)
- Write<int32_t>(kSectionMarker);
-#endif
- }
for (SerializationCluster* cluster : clusters) {
cluster->WriteAndMeasureFill(this);
#if defined(DEBUG)
@@ -7110,11 +7136,10 @@
return;
}
- auto const code_cluster = CID_CLUSTER(Code);
- ASSERT(code_cluster != nullptr);
+ ASSERT(code_cluster_ != nullptr);
// Reference IDs in a cluster are allocated sequentially, so we can use the
// first code object's reference ID to calculate the cluster index.
- const intptr_t first_code_id = RefId(code_cluster->objects()->At(0));
+ const intptr_t first_code_id = RefId(code_cluster_->objects()->At(0));
// The first object in the code cluster must have its reference ID allocated.
ASSERT(IsAllocatedReference(first_code_id));
@@ -7194,9 +7219,16 @@
void Serializer::PrintSnapshotSizes() {
#if !defined(DART_PRECOMPILED_RUNTIME)
if (FLAG_print_snapshot_sizes_verbose) {
- OS::PrintErr(
- " Cluster Objs Size Fraction Cumulative "
- " HeapSize\n");
+ TextBuffer buffer(1024);
+ // Header, using format sizes matching those below to ensure alignment.
+ buffer.Printf("%25s", "Cluster");
+ buffer.Printf(" %6s", "Objs");
+ buffer.Printf(" %8s", "Size");
+ buffer.Printf(" %8s", "Fraction");
+ buffer.Printf(" %10s", "Cumulative");
+ buffer.Printf(" %8s", "HeapSize");
+ buffer.Printf(" %5s", "Cid");
+ buffer.AddString("\n");
GrowableArray<SerializationCluster*> clusters_by_size;
for (intptr_t cid = 1; cid < num_cids_; cid++) {
if (auto const cluster = canonical_clusters_by_cid_[cid]) {
@@ -7251,11 +7283,20 @@
SerializationCluster* cluster = clusters_by_size[i];
double fraction = static_cast<double>(cluster->size()) / total_size;
cumulative_fraction += fraction;
- OS::PrintErr("%25s %6" Pd " %8" Pd " %lf %lf %8" Pd "\n",
- cluster->name(), cluster->num_objects(), cluster->size(),
- fraction, cumulative_fraction,
- cluster->target_memory_size());
+ buffer.Printf("%25s", cluster->name());
+ buffer.Printf(" %6" Pd "", cluster->num_objects());
+ buffer.Printf(" %8" Pd "", cluster->size());
+ buffer.Printf(" %1.6lf", fraction);
+ buffer.Printf(" %1.8lf", cumulative_fraction);
+ buffer.Printf(" %8" Pd "", cluster->target_memory_size());
+ if (cluster->cid() != -1) {
+ buffer.Printf(" %5" Pd "", cluster->cid());
+ } else {
+ buffer.Printf(" %5s", "");
+ }
+ buffer.AddString("\n");
}
+ OS::PrintErr("%s", buffer.buffer());
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
}
@@ -7277,7 +7318,6 @@
refs_(nullptr),
next_ref_index_(kFirstReference),
previous_text_offset_(0),
- canonical_clusters_(nullptr),
clusters_(nullptr),
initial_field_table_(thread->isolate_group()->initial_field_table()),
is_non_root_unit_(is_non_root_unit),
@@ -7291,23 +7331,27 @@
}
Deserializer::~Deserializer() {
- delete[] canonical_clusters_;
delete[] clusters_;
}
DeserializationCluster* Deserializer::ReadCluster() {
- intptr_t cid = ReadCid();
+ const uint64_t cid_and_canonical = Read<uint64_t>();
+ const intptr_t cid = (cid_and_canonical >> 1) & kMaxUint32;
+ const bool is_canonical = (cid_and_canonical & 0x1) == 0x1;
Zone* Z = zone_;
if (cid >= kNumPredefinedCids || cid == kInstanceCid) {
- return new (Z) InstanceDeserializationCluster(cid);
+ return new (Z) InstanceDeserializationCluster(cid, is_canonical);
}
if (IsTypedDataViewClassId(cid)) {
+ ASSERT(!is_canonical);
return new (Z) TypedDataViewDeserializationCluster(cid);
}
if (IsExternalTypedDataClassId(cid)) {
+ ASSERT(!is_canonical);
return new (Z) ExternalTypedDataDeserializationCluster(cid);
}
if (IsTypedDataClassId(cid)) {
+ ASSERT(!is_canonical);
return new (Z) TypedDataDeserializationCluster(cid);
}
@@ -7317,113 +7361,148 @@
case kPcDescriptorsCid:
case kCodeSourceMapCid:
case kCompressedStackMapsCid:
- return new (Z) RODataDeserializationCluster(!is_non_root_unit_, cid);
+ return new (Z)
+ RODataDeserializationCluster(is_canonical, !is_non_root_unit_, cid);
case kOneByteStringCid:
case kTwoByteStringCid:
if (!is_non_root_unit_) {
- return new (Z) RODataDeserializationCluster(!is_non_root_unit_, cid);
+ return new (Z) RODataDeserializationCluster(is_canonical,
+ !is_non_root_unit_, cid);
}
break;
case kStringCid:
RELEASE_ASSERT(!is_non_root_unit_);
- return new (Z) RODataDeserializationCluster(!is_non_root_unit_, cid);
+ return new (Z)
+ RODataDeserializationCluster(is_canonical, !is_non_root_unit_, cid);
}
}
#endif
switch (cid) {
case kClassCid:
+ ASSERT(!is_canonical);
return new (Z) ClassDeserializationCluster();
case kTypeArgumentsCid:
- return new (Z) TypeArgumentsDeserializationCluster(!is_non_root_unit_);
+ return new (Z)
+ TypeArgumentsDeserializationCluster(is_canonical, !is_non_root_unit_);
case kPatchClassCid:
+ ASSERT(!is_canonical);
return new (Z) PatchClassDeserializationCluster();
case kFunctionCid:
+ ASSERT(!is_canonical);
return new (Z) FunctionDeserializationCluster();
case kClosureDataCid:
+ ASSERT(!is_canonical);
return new (Z) ClosureDataDeserializationCluster();
case kFfiTrampolineDataCid:
+ ASSERT(!is_canonical);
return new (Z) FfiTrampolineDataDeserializationCluster();
case kFieldCid:
+ ASSERT(!is_canonical);
return new (Z) FieldDeserializationCluster();
case kScriptCid:
+ ASSERT(!is_canonical);
return new (Z) ScriptDeserializationCluster();
case kLibraryCid:
+ ASSERT(!is_canonical);
return new (Z) LibraryDeserializationCluster();
case kNamespaceCid:
+ ASSERT(!is_canonical);
return new (Z) NamespaceDeserializationCluster();
#if !defined(DART_PRECOMPILED_RUNTIME)
case kKernelProgramInfoCid:
+ ASSERT(!is_canonical);
return new (Z) KernelProgramInfoDeserializationCluster();
#endif // !DART_PRECOMPILED_RUNTIME
case kCodeCid:
+ ASSERT(!is_canonical);
return new (Z) CodeDeserializationCluster();
case kObjectPoolCid:
+ ASSERT(!is_canonical);
return new (Z) ObjectPoolDeserializationCluster();
case kPcDescriptorsCid:
+ ASSERT(!is_canonical);
return new (Z) PcDescriptorsDeserializationCluster();
case kCodeSourceMapCid:
+ ASSERT(!is_canonical);
return new (Z) CodeSourceMapDeserializationCluster();
case kCompressedStackMapsCid:
+ ASSERT(!is_canonical);
return new (Z) CompressedStackMapsDeserializationCluster();
case kExceptionHandlersCid:
+ ASSERT(!is_canonical);
return new (Z) ExceptionHandlersDeserializationCluster();
case kContextCid:
+ ASSERT(!is_canonical);
return new (Z) ContextDeserializationCluster();
case kContextScopeCid:
+ ASSERT(!is_canonical);
return new (Z) ContextScopeDeserializationCluster();
case kUnlinkedCallCid:
+ ASSERT(!is_canonical);
return new (Z) UnlinkedCallDeserializationCluster();
case kICDataCid:
+ ASSERT(!is_canonical);
return new (Z) ICDataDeserializationCluster();
case kMegamorphicCacheCid:
+ ASSERT(!is_canonical);
return new (Z) MegamorphicCacheDeserializationCluster();
case kSubtypeTestCacheCid:
+ ASSERT(!is_canonical);
return new (Z) SubtypeTestCacheDeserializationCluster();
case kLoadingUnitCid:
+ ASSERT(!is_canonical);
return new (Z) LoadingUnitDeserializationCluster();
case kLanguageErrorCid:
+ ASSERT(!is_canonical);
return new (Z) LanguageErrorDeserializationCluster();
case kUnhandledExceptionCid:
+ ASSERT(!is_canonical);
return new (Z) UnhandledExceptionDeserializationCluster();
case kLibraryPrefixCid:
+ ASSERT(!is_canonical);
return new (Z) LibraryPrefixDeserializationCluster();
case kTypeCid:
- return new (Z) TypeDeserializationCluster(!is_non_root_unit_);
+ return new (Z)
+ TypeDeserializationCluster(is_canonical, !is_non_root_unit_);
case kFunctionTypeCid:
- return new (Z) FunctionTypeDeserializationCluster(!is_non_root_unit_);
+ return new (Z)
+ FunctionTypeDeserializationCluster(is_canonical, !is_non_root_unit_);
case kTypeRefCid:
+ ASSERT(!is_canonical);
return new (Z) TypeRefDeserializationCluster();
case kTypeParameterCid:
- return new (Z) TypeParameterDeserializationCluster(!is_non_root_unit_);
+ return new (Z)
+ TypeParameterDeserializationCluster(is_canonical, !is_non_root_unit_);
case kClosureCid:
- return new (Z) ClosureDeserializationCluster();
+ return new (Z) ClosureDeserializationCluster(is_canonical);
case kMintCid:
- return new (Z) MintDeserializationCluster();
+ return new (Z) MintDeserializationCluster(is_canonical);
case kDoubleCid:
- return new (Z) DoubleDeserializationCluster();
+ return new (Z) DoubleDeserializationCluster(is_canonical);
case kGrowableObjectArrayCid:
+ ASSERT(!is_canonical);
return new (Z) GrowableObjectArrayDeserializationCluster();
case kStackTraceCid:
+ ASSERT(!is_canonical);
return new (Z) StackTraceDeserializationCluster();
case kRegExpCid:
+ ASSERT(!is_canonical);
return new (Z) RegExpDeserializationCluster();
case kWeakPropertyCid:
+ ASSERT(!is_canonical);
return new (Z) WeakPropertyDeserializationCluster();
case kLinkedHashMapCid:
- return new (Z) LinkedHashMapDeserializationCluster();
+ return new (Z) LinkedHashMapDeserializationCluster(is_canonical);
case kArrayCid:
- return new (Z) ArrayDeserializationCluster(kArrayCid);
+ return new (Z) ArrayDeserializationCluster(is_canonical, kArrayCid);
case kImmutableArrayCid:
- return new (Z) ArrayDeserializationCluster(kImmutableArrayCid);
+ return new (Z)
+ ArrayDeserializationCluster(is_canonical, kImmutableArrayCid);
case kOneByteStringCid:
- return new (Z) OneByteStringDeserializationCluster();
+ return new (Z) OneByteStringDeserializationCluster(is_canonical);
case kTwoByteStringCid:
- return new (Z) TwoByteStringDeserializationCluster();
- case kWeakSerializationReferenceCid:
-#if defined(DART_PRECOMPILED_RUNTIME)
- return new (Z) WeakSerializationReferenceDeserializationCluster();
-#endif
+ return new (Z) TwoByteStringDeserializationCluster(is_canonical);
default:
break;
}
@@ -7772,12 +7851,10 @@
Array& refs = Array::Handle(zone_);
num_base_objects_ = ReadUnsigned();
num_objects_ = ReadUnsigned();
- num_canonical_clusters_ = ReadUnsigned();
num_clusters_ = ReadUnsigned();
const intptr_t initial_field_table_len = ReadUnsigned();
const intptr_t instructions_table_len = ReadUnsigned();
- canonical_clusters_ = new DeserializationCluster*[num_canonical_clusters_];
clusters_ = new DeserializationCluster*[num_clusters_];
refs = Array::New(num_objects_ + kFirstReference, Heap::kOld);
if (initial_field_table_len > 0) {
@@ -7825,19 +7902,10 @@
{
TIMELINE_DURATION(thread(), Isolate, "ReadAlloc");
- for (intptr_t i = 0; i < num_canonical_clusters_; i++) {
- canonical_clusters_[i] = ReadCluster();
- TIMELINE_DURATION(thread(), Isolate, canonical_clusters_[i]->name());
- canonical_clusters_[i]->ReadAlloc(this, /*is_canonical*/ true);
-#if defined(DEBUG)
- intptr_t serializers_next_ref_index_ = Read<int32_t>();
- ASSERT_EQUAL(serializers_next_ref_index_, next_ref_index_);
-#endif
- }
for (intptr_t i = 0; i < num_clusters_; i++) {
clusters_[i] = ReadCluster();
TIMELINE_DURATION(thread(), Isolate, clusters_[i]->name());
- clusters_[i]->ReadAlloc(this, /*is_canonical*/ false);
+ clusters_[i]->ReadAlloc(this);
#if defined(DEBUG)
intptr_t serializers_next_ref_index_ = Read<int32_t>();
ASSERT_EQUAL(serializers_next_ref_index_, next_ref_index_);
@@ -7850,18 +7918,9 @@
{
TIMELINE_DURATION(thread(), Isolate, "ReadFill");
- for (intptr_t i = 0; i < num_canonical_clusters_; i++) {
- TIMELINE_DURATION(thread(), Isolate, canonical_clusters_[i]->name());
- bool stamp_canonical = primary;
- canonical_clusters_[i]->ReadFill(this, stamp_canonical);
-#if defined(DEBUG)
- int32_t section_marker = Read<int32_t>();
- ASSERT(section_marker == kSectionMarker);
-#endif
- }
for (intptr_t i = 0; i < num_clusters_; i++) {
TIMELINE_DURATION(thread(), Isolate, clusters_[i]->name());
- clusters_[i]->ReadFill(this, /*stamp_canonical*/ false);
+ clusters_[i]->ReadFill(this, primary);
#if defined(DEBUG)
int32_t section_marker = Read<int32_t>();
ASSERT(section_marker == kSectionMarker);
@@ -7891,14 +7950,9 @@
{
TIMELINE_DURATION(thread(), Isolate, "PostLoad");
- for (intptr_t i = 0; i < num_canonical_clusters_; i++) {
- TIMELINE_DURATION(thread(), Isolate, canonical_clusters_[i]->name());
- bool canonicalize = !primary;
- canonical_clusters_[i]->PostLoad(this, refs, canonicalize);
- }
for (intptr_t i = 0; i < num_clusters_; i++) {
TIMELINE_DURATION(thread(), Isolate, clusters_[i]->name());
- clusters_[i]->PostLoad(this, refs, /*canonicalize*/ false);
+ clusters_[i]->PostLoad(this, refs, primary);
}
}
}
diff --git a/runtime/vm/clustered_snapshot.h b/runtime/vm/clustered_snapshot.h
index a7a1e6a..ac3e31b 100644
--- a/runtime/vm/clustered_snapshot.h
+++ b/runtime/vm/clustered_snapshot.h
@@ -79,13 +79,17 @@
class SerializationCluster : public ZoneAllocated {
public:
+ static constexpr intptr_t kSizeVaries = -1;
explicit SerializationCluster(const char* name,
- intptr_t target_instance_size = 0)
+ intptr_t cid,
+ intptr_t target_instance_size = kSizeVaries,
+ bool is_canonical = false)
: name_(name),
- size_(0),
- num_objects_(0),
+ cid_(cid),
target_instance_size_(target_instance_size),
- target_memory_size_(0) {}
+ is_canonical_(is_canonical) {
+ ASSERT(target_instance_size == kSizeVaries || target_instance_size >= 0);
+ }
virtual ~SerializationCluster() {}
// Add [object] to the cluster and push its outgoing references.
@@ -103,6 +107,8 @@
void WriteAndMeasureFill(Serializer* serializer);
const char* name() const { return name_; }
+ intptr_t cid() const { return cid_; }
+ bool is_canonical() const { return is_canonical_; }
intptr_t size() const { return size_; }
intptr_t num_objects() const { return num_objects_; }
@@ -116,40 +122,47 @@
intptr_t target_memory_size() const { return target_memory_size_; }
protected:
- const char* name_;
- intptr_t size_;
- intptr_t num_objects_;
+ const char* const name_;
+ const intptr_t cid_;
const intptr_t target_instance_size_;
- intptr_t target_memory_size_;
+ const bool is_canonical_;
+ intptr_t size_ = 0;
+ intptr_t num_objects_ = 0;
+ intptr_t target_memory_size_ = 0;
};
class DeserializationCluster : public ZoneAllocated {
public:
- explicit DeserializationCluster(const char* name)
- : name_(name), start_index_(-1), stop_index_(-1) {}
+ explicit DeserializationCluster(const char* name, bool is_canonical = false)
+ : name_(name),
+ is_canonical_(is_canonical),
+ start_index_(-1),
+ stop_index_(-1) {}
virtual ~DeserializationCluster() {}
// Allocate memory for all objects in the cluster and write their addresses
// into the ref array. Do not touch this memory.
- virtual void ReadAlloc(Deserializer* deserializer, bool stamp_canonical) = 0;
+ virtual void ReadAlloc(Deserializer* deserializer) = 0;
// Initialize the cluster's objects. Do not touch the memory of other objects.
- virtual void ReadFill(Deserializer* deserializer, bool stamp_canonical) = 0;
+ virtual void ReadFill(Deserializer* deserializer, bool primary) = 0;
// Complete any action that requires the full graph to be deserialized, such
// as rehashing.
virtual void PostLoad(Deserializer* deserializer,
const Array& refs,
- bool canonicalize) {
- if (canonicalize) {
+ bool primary) {
+ if (!primary && is_canonical()) {
FATAL1("%s needs canonicalization but doesn't define PostLoad", name());
}
}
const char* name() const { return name_; }
+ bool is_canonical() const { return is_canonical_; }
protected:
- const char* name_;
+ const char* const name_;
+ const bool is_canonical_;
// The range of the ref array that belongs to this cluster.
intptr_t start_index_;
intptr_t stop_index_;
@@ -198,6 +211,8 @@
return ref == kUnallocatedReference || IsAllocatedReference(ref);
}
+class CodeSerializationCluster;
+
class Serializer : public ThreadStackResource {
public:
Serializer(Thread* thread,
@@ -473,6 +488,7 @@
ImageWriter* image_writer_;
SerializationCluster** canonical_clusters_by_cid_;
SerializationCluster** clusters_by_cid_;
+ CodeSerializationCluster* code_cluster_ = nullptr;
GrowableArray<ObjectPtr> stack_;
intptr_t num_cids_;
intptr_t num_tlc_cids_;
@@ -533,7 +549,6 @@
#define WriteCompressedField(obj, name) \
s->WritePropertyRef(obj->untag()->name(), #name "_")
-
// This class can be used to read version and features from a snapshot before
// the VM has been initialized.
class SnapshotHeaderReader {
@@ -693,14 +708,12 @@
ImageReader* image_reader_;
intptr_t num_base_objects_;
intptr_t num_objects_;
- intptr_t num_canonical_clusters_;
intptr_t num_clusters_;
ArrayPtr refs_;
intptr_t next_ref_index_;
intptr_t previous_text_offset_;
intptr_t code_start_index_ = 0;
intptr_t instructions_index_ = 0;
- DeserializationCluster** canonical_clusters_;
DeserializationCluster** clusters_;
FieldTable* initial_field_table_;
const bool is_non_root_unit_;
diff --git a/runtime/vm/image_snapshot.cc b/runtime/vm/image_snapshot.cc
index 344ae25..eaffe44 100644
--- a/runtime/vm/image_snapshot.cc
+++ b/runtime/vm/image_snapshot.cc
@@ -651,14 +651,14 @@
const char* bss_symbol = SectionSymbol(ProgramSection::Bss, vm);
ASSERT(bss_symbol != nullptr);
- if (FLAG_precompiled_mode) {
- if (profile_writer_ != nullptr) {
- profile_writer_->SetObjectTypeAndName(parent_id, image_type_,
- instructions_symbol);
- profile_writer_->AttributeBytesTo(parent_id, Image::kHeaderSize);
- profile_writer_->AddRoot(parent_id);
- }
+ if (profile_writer_ != nullptr) {
+ profile_writer_->SetObjectTypeAndName(parent_id, image_type_,
+ instructions_symbol);
+ profile_writer_->AttributeBytesTo(parent_id, Image::kHeaderSize);
+ profile_writer_->AddRoot(parent_id);
+ }
+ if (FLAG_precompiled_mode) {
const intptr_t section_header_length =
compiler::target::InstructionsSection::HeaderSize();
// Calculated using next_text_offset_, which doesn't include post-payload
diff --git a/runtime/vm/v8_snapshot_writer.cc b/runtime/vm/v8_snapshot_writer.cc
index 6fb5898..351c831 100644
--- a/runtime/vm/v8_snapshot_writer.cc
+++ b/runtime/vm/v8_snapshot_writer.cc
@@ -29,8 +29,6 @@
idx = edge_types_.Add("internal");
ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kInternal));
- unknown_type_string_index_ = node_types_.Add("Unknown");
-
SetObjectTypeAndName(kArtificialRootId, "ArtificialRoot",
"<artificial root>");
}
@@ -113,14 +111,10 @@
void V8SnapshotProfileWriter::NodeInfo::Write(JSONWriter* writer) const {
ASSERT(id.space() != IdSpace::kInvalid);
- ASSERT(type != kInvalidString);
if (type == kInvalidString) {
- // Fall back on this string in non-DEBUG modes. See
- // https://github.com/dart-lang/sdk/issues/45787 for context.
- writer->PrintValue(profile_writer_->unknown_type_string_index_);
- } else {
- writer->PrintValue(type);
+ FATAL("No type given for node %s", id.ToCString(profile_writer_->zone_));
}
+ writer->PrintValue(type);
if (name != kInvalidString) {
writer->PrintValue(name);
} else {
diff --git a/runtime/vm/v8_snapshot_writer.h b/runtime/vm/v8_snapshot_writer.h
index 9aededc..ea0a0e7 100644
--- a/runtime/vm/v8_snapshot_writer.h
+++ b/runtime/vm/v8_snapshot_writer.h
@@ -331,7 +331,6 @@
StringsTable edge_types_;
StringsTable strings_;
DirectChainedHashMap<ObjectIdSetKeyValueTrait> roots_;
- intptr_t unknown_type_string_index_;
#endif
};
diff --git a/tests/co19/co19-dartdevc.status b/tests/co19/co19-dartdevc.status
index d97af6e..f0c1a51 100644
--- a/tests/co19/co19-dartdevc.status
+++ b/tests/co19/co19-dartdevc.status
@@ -3,62 +3,11 @@
# BSD-style license that can be found in the LICENSE file.
[ $compiler == dartdevc || $compiler == dartdevk ]
-Language/Classes/Constructors/Generative_Constructors/formal_parameter_t07: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/fresh_instance_t01: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/implicit_superinitializer_t01: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/implicit_superinitializer_t02: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/initializers_t01: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/initializers_t15: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/initializing_formals_execution_t01: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/initializing_this_t01: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/redirection_t01: SkipSlow
-Language/Classes/Constructors/Generative_Constructors/syntax_t01: SkipSlow
-Language/Classes/Constructors/implicit_constructor_t01: SkipSlow
-Language/Classes/Constructors/implicit_constructor_t02: SkipSlow
-Language/Classes/Constructors/name_t01: SkipSlow
-Language/Classes/Constructors/name_t02: SkipSlow
-Language/Classes/Constructors/name_t03: SkipSlow
-Language/Classes/Getters/instance_getter_t01: SkipSlow
-Language/Classes/Getters/instance_getter_t02: SkipSlow
-Language/Classes/Getters/instance_getter_t03: SkipSlow
-Language/Classes/Getters/instance_getter_t04: SkipSlow
-Language/Classes/Getters/instance_getter_t05: SkipSlow
-Language/Classes/Getters/instance_getter_t06: SkipSlow
-Language/Classes/Getters/override_t04: SkipSlow
-Language/Classes/Getters/return_type_t01: SkipSlow
-Language/Classes/Getters/static_t01/none: SkipSlow
-Language/Classes/Getters/static_t02: SkipSlow
-Language/Classes/Getters/syntax_t01: SkipSlow
-Language/Classes/Getters/void_return_type_t01: SkipSlow
-Language/Classes/Instance_Methods/Operators/allowed_names_t01: SkipSlow
-Language/Classes/Instance_Methods/Operators/arity_0_or_1_t01: SkipSlow
-Language/Classes/Instance_Methods/Operators/arity_0_t01: SkipSlow
-Language/Classes/Instance_Methods/Operators/syntax_t01: SkipSlow
-Language/Classes/Instance_Methods/Operators/syntax_t03: SkipSlow
-Language/Classes/Instance_Methods/override_named_parameters_t03: SkipSlow
-Language/Classes/Instance_Methods/override_named_parameters_t04: SkipSlow
-Language/Classes/Instance_Methods/override_named_parameters_t06: SkipSlow
-Language/Classes/Instance_Methods/override_subtype_t05: SkipSlow
-Language/Classes/Instance_Methods/override_subtype_t06: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t01: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t02: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t04: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t05: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t06: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t07: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t08: SkipSlow
-Language/Classes/Instance_Methods/same_name_static_member_in_superclass_t09: SkipSlow
-Language/Classes/Instance_Variables/definition_t01: SkipSlow
-Language/Classes/Instance_Variables/definition_t02: SkipSlow
-Language/Classes/Instance_Variables/definition_t04: SkipSlow
-Language/Classes/Setters/instance_setter_t01: SkipSlow
Language/Expressions/Constants/integer_size_t03: SkipByDesign # uses integer literal not representable as JavaScript number
Language/Expressions/Constants/integer_size_t04: SkipByDesign # uses integer literal not representable as JavaScript number
Language/Expressions/Constants/literal_number_t01: SkipByDesign # uses integer literal not representable as JavaScript number
Language/Expressions/Constants/math_operators_t01: SkipByDesign # uses integer literal not representable as JavaScript number
Language/Expressions/Constants/math_operators_t06: SkipByDesign # uses integer literal not representable as JavaScript number
-Language/Expressions/Function_Invocation/async_generator_invokation_t08: SkipSlow
-Language/Expressions/Function_Invocation/async_generator_invokation_t10: SkipSlow
Language/Expressions/Null/instance_of_class_null_t01: SkipByDesign # dart:mirrors not supported https://github.com/dart-lang/co19/issues/522
Language/Expressions/Numbers/integer_size_t03: SkipByDesign # uses integer literal not representable as JavaScript number
Language/Expressions/Numbers/static_type_of_int_t01: SkipByDesign # uses integer literal not representable as JavaScript number
@@ -74,8 +23,6 @@
Language/Metadata/before*: SkipByDesign # dart:mirrors not supported https://github.com/dart-lang/co19/issues/523
Language/Metadata/syntax_t10: SkipByDesign # dart:mirrors is not supported
Language/Reference/Operator_Precedence/precedence_15_unary_prefix_t08: SkipByDesign # binary '~' produces different results in JavaScript and Dart
-Language/Types/Interface_Types/subtype_t27: SkipSlow
-Language/Types/Interface_Types/subtype_t28: SkipSlow
LanguageFeatures/Abstract-external-fields/static_analysis_external_A01_t01: SkipByDesign # External variables are not supported
LanguageFeatures/Abstract-external-fields/static_analysis_external_A01_t02: SkipByDesign # External variables are not supported
LanguageFeatures/Abstract-external-fields/static_analysis_external_A01_t03: SkipByDesign # External variables are not supported
@@ -105,12 +52,8 @@
LibTest/core/int/parse_A01_t02: SkipByDesign # big integers cannot be represented in JavaScript
LibTest/core/int/remainder_A01_t03: SkipByDesign # Division by zero is not an error in JavaScript
LibTest/ffi/*: SkipByDesign # dart:ffi is not supported
-LibTest/html/Element/blur_A01_t01: SkipSlow
-LibTest/html/Element/focus_A01_t01: SkipSlow
LibTest/html/HttpRequest/responseText_A01_t02: Skip # https://github.com/dart-lang/co19/issues/932
LibTest/html/HttpRequestUpload/*: Skip # https://github.com/dart-lang/co19/issues/932
-LibTest/html/IFrameElement/blur_A01_t01: SkipSlow
-LibTest/html/IFrameElement/focus_A01_t01: SkipSlow
LibTest/io/*: SkipByDesign # dart:io not supported.
LibTest/isolate/*: SkipByDesign # dart:isolate not supported.
LibTest/mirrors/*: SkipByDesign # dart:mirrors is not supported
diff --git a/tests/co19/co19-kernel.status b/tests/co19/co19-kernel.status
index 088865a..c62ddcc 100644
--- a/tests/co19/co19-kernel.status
+++ b/tests/co19/co19-kernel.status
@@ -3,14 +3,7 @@
# BSD-style license that can be found in the LICENSE file.
[ $compiler == dartk ]
-Language/Libraries_and_Scripts/Scripts/top_level_main_t01: Crash
-LibTest/isolate/SendPort/send_A01_t02: Crash
-LibTest/isolate/SendPort/send_A01_t03: Crash
-
-[ $compiler == fasta ]
-Language/Statements/For/syntax_t13: Crash # Assertion error: kernel_shadow_ast.dart: 'receiver == null': is not true.
-Language/Statements/For/syntax_t20: Crash # Assertion error: kernel_shadow_ast.dart: 'receiver == null': is not true.
-LanguageFeatures/Constant-update-2018/NewOperators_A01_t06/none: Crash
+Language/Libraries_and_Scripts/Scripts/top_level_main_t01: Crash # https://github.com/dart-lang/sdk/issues/42487
[ $runtime == dart_precompiled ]
Language/Metadata/syntax_t10: SkipByDesign # dart:mirrors is not supported
@@ -30,9 +23,6 @@
LibTest/core/List/List_class_A01_t02: Slow, Pass # Does many calls
LibTest/io/RawDatagramSocket/*: Skip # RawDatagramSocket are flaky. https://github.com/dart-lang/co19/issues/195
-[ $compiler == dartk && $runtime == vm && $system == linux ]
-LibTest/isolate/Isolate/spawn_A06_t03: Crash
-
[ $compiler == dartk && $runtime == vm && $system == macos ]
LibTest/collection/ListBase/ListBase_class_A01_t02: Slow, Pass
LibTest/collection/ListBase/ListBase_class_A01_t03: Slow, Pass
@@ -41,9 +31,6 @@
LibTest/core/List/List_class_A01_t02: Slow, Pass
LibTest/core/List/List_class_A01_t03: Slow, Pass
-[ $compiler == dartk && $runtime != vm ]
-Language/Classes/Constructors/Constant_Constructors/potentially_constant_expression_t01: Crash
-
[ $runtime == dart_precompiled && ($arch == simarm64 || $arch == simarm64c) ]
LibTest/collection/ListBase/ListBase_class_A01_t01: SkipSlow # Issue 43036
LibTest/collection/ListMixin/ListMixin_class_A01_t01: SkipSlow # Issue 43036
diff --git a/tests/co19/co19-runtime.status b/tests/co19/co19-runtime.status
index 80fa459..f810625 100644
--- a/tests/co19/co19-runtime.status
+++ b/tests/co19/co19-runtime.status
@@ -2,17 +2,10 @@
# 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.
-[ $runtime != none ]
-LibTest/core/Uri/hasEmptyPath_A01_t01: RuntimeError
-LibTest/core/Uri/parse_A05_t01: RuntimeError
-
[ $system == windows ]
LibTest/io/Stdin/readByteSync_A01_t01: Skip # Issue 43645
LibTest/io/Stdin/readByteSync_A01_t02: Skip # Issue 43645
-[ $compiler != dart2js && $runtime != none && $runtime != vm && !$checked ]
-LibTest/async/Future/catchError_A03_t05: RuntimeError
-
[ $mode == debug && $runtime == dart_precompiled ]
LibTest/collection/ListBase/ListBase_class_A01_t03: SkipSlow # Very slow compilation in debug mode.
LibTest/collection/ListBase/ListBase_class_A01_t04: SkipSlow # Very slow compilation in debug mode.
diff --git a/tests/language/why_not_promoted/nullable_operator_call_error.dart b/tests/language/why_not_promoted/nullable_operator_call_error.dart
new file mode 100644
index 0000000..a145f34
--- /dev/null
+++ b/tests/language/why_not_promoted/nullable_operator_call_error.dart
@@ -0,0 +1,37 @@
+// Copyright (c) 2021, 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 contains a test case for each condition that can lead to the front
+// end's `NullableOperatorCallError` error, for which we wish to report "why not
+// promoted" context information.
+
+class C1 {
+ int? bad;
+ // ^^^
+ // [context 2] 'bad' refers to a property so it couldn't be promoted. See http://dart.dev/go/non-promo-property
+ // [context 3] 'bad' refers to a property so it couldn't be promoted.
+}
+
+userDefinableBinaryOpLhs(C1 c) {
+ if (c.bad == null) return;
+ c.bad + 1;
+ // ^
+ // [analyzer 2] COMPILE_TIME_ERROR.UNCHECKED_USE_OF_NULLABLE_VALUE
+ // [cfe 3] Operator '+' cannot be called on 'int?' because it is potentially null.
+}
+
+class C2 {
+ int? bad;
+ // ^^^
+ // [context 1] 'bad' refers to a property so it couldn't be promoted. See http://dart.dev/go/non-promo-property
+ // [context 4] 'bad' refers to a property so it couldn't be promoted.
+}
+
+userDefinableUnaryOp(C2 c) {
+ if (c.bad == null) return;
+ -c.bad;
+//^
+// [analyzer 1] COMPILE_TIME_ERROR.UNCHECKED_USE_OF_NULLABLE_VALUE
+// [cfe 4] Operator 'unary-' cannot be called on 'int?' because it is potentially null.
+}
diff --git a/tools/VERSION b/tools/VERSION
index 0db4e9f..4eca9c2 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 14
PATCH 0
-PRERELEASE 29
+PRERELEASE 30
PRERELEASE_PATCH 0
\ No newline at end of file
