runtime/vm/compiler/backend/flow_graph_test.cc - sdk.git - Git at Google

 // Copyright (c) 2012, 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.

 #include "vm/compiler/backend/flow_graph.h"

 #include <vector>

 #include "platform/text_buffer.h"
 #include "platform/utils.h"
 #include "vm/compiler/backend/block_builder.h"
 #include "vm/compiler/backend/flow_graph_compiler.h"
 #include "vm/compiler/backend/il_printer.h"
 #include "vm/compiler/backend/il_test_helper.h"
 #include "vm/compiler/backend/type_propagator.h"
 #include "vm/unit_test.h"

 namespace dart {

 #if defined(TARGET_ARCH_IS_64_BIT)
 ISOLATE_UNIT_TEST_CASE(FlowGraph_UnboxInt64Phi) {
   using compiler::BlockBuilder;

   CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);

   FlowGraphBuilderHelper H;

   // Add a variable into the scope which would provide static type for the
   // parameter.
   LocalVariable* v0_var =
       new LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                         String::Handle(Symbols::New(thread, "v0")),
                         AbstractType::ZoneHandle(Type::IntType()),
                         new CompileType(CompileType::Int()));
   v0_var->set_type_check_mode(LocalVariable::kTypeCheckedByCaller);
   H.flow_graph()->parsed_function().scope()->AddVariable(v0_var);

   auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
   auto loop_header = H.JoinEntry();
   auto loop_body = H.TargetEntry();
   auto loop_exit = H.TargetEntry();

   Definition* v0;
   PhiInstr* loop_var;
   Definition* add1;

   {
     BlockBuilder builder(H.flow_graph(), normal_entry);
     v0 = builder.AddParameter(0, 0, /*with_frame=*/true, kTagged);
     builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
   }

   {
     BlockBuilder builder(H.flow_graph(), loop_header);
     loop_var = H.Phi(loop_header, {{normal_entry, v0}, {loop_body, &add1}});
     builder.AddPhi(loop_var);
     builder.AddBranch(new RelationalOpInstr(
                           InstructionSource(), Token::kLT, new Value(loop_var),
                           new Value(H.IntConstant(50)), kMintCid,
                           S.GetNextDeoptId(), Instruction::kNotSpeculative),
                       loop_body, loop_exit);
   }

   {
     BlockBuilder builder(H.flow_graph(), loop_body);
     add1 = builder.AddDefinition(new BinaryInt64OpInstr(
         Token::kADD, new Value(loop_var), new Value(H.IntConstant(1)),
         S.GetNextDeoptId(), Instruction::kNotSpeculative));
     builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
   }

   {
     BlockBuilder builder(H.flow_graph(), loop_exit);
     builder.AddReturn(new Value(loop_var));
   }

   H.FinishGraph();

   FlowGraphTypePropagator::Propagate(H.flow_graph());
   H.flow_graph()->SelectRepresentations();

   EXPECT_PROPERTY(loop_var, it.representation() == kUnboxedInt64);
 }
 #endif  // defined(TARGET_ARCH_IS_64_BIT)

 ISOLATE_UNIT_TEST_CASE(FlowGraph_LateVariablePhiUnboxing) {
   using compiler::BlockBuilder;

   CompilerState S(thread, /*is_aot=*/true, /*is_optimizing=*/true);
   FlowGraphBuilderHelper H;

   auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
   auto loop_header = H.JoinEntry();
   auto loop_body = H.TargetEntry();
   auto loop_exit = H.TargetEntry();

   ConstantInstr* sentinel = H.flow_graph()->GetConstant(Object::sentinel());

   PhiInstr* loop_var;
   PhiInstr* late_var;
   Definition* add1;

   {
     BlockBuilder builder(H.flow_graph(), normal_entry);
     builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
   }

   {
     BlockBuilder builder(H.flow_graph(), loop_header);
     loop_var = H.Phi(loop_header,
                      {{normal_entry, H.IntConstant(0)}, {loop_body, &add1}});
     builder.AddPhi(loop_var);
     loop_var->UpdateType(CompileType::Int());
     loop_var->UpdateType(CompileType::FromAbstractType(
         Type::ZoneHandle(Type::IntType()), CompileType::kCannotBeNull,
         CompileType::kCanBeSentinel));
     late_var =
         H.Phi(loop_header, {{normal_entry, sentinel}, {loop_body, &add1}});
     builder.AddPhi(late_var);
     builder.AddBranch(new RelationalOpInstr(
                           InstructionSource(), Token::kLT, new Value(loop_var),
                           new Value(H.IntConstant(10)), kMintCid,
                           S.GetNextDeoptId(), Instruction::kNotSpeculative),
                       loop_body, loop_exit);
   }

   {
     BlockBuilder builder(H.flow_graph(), loop_body);
     add1 = builder.AddDefinition(new BinaryInt64OpInstr(
         Token::kADD, new Value(loop_var), new Value(H.IntConstant(1)),
         S.GetNextDeoptId(), Instruction::kNotSpeculative));
     builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
   }

   {
     BlockBuilder builder(H.flow_graph(), loop_exit);
     builder.AddReturn(new Value(late_var));
   }

   H.FinishGraph();

   FlowGraphTypePropagator::Propagate(H.flow_graph());
   H.flow_graph()->SelectRepresentations();

 #if defined(TARGET_ARCH_IS_64_BIT)
   EXPECT_PROPERTY(loop_var, it.representation() == kUnboxedInt64);
 #endif
   EXPECT_PROPERTY(late_var, it.representation() == kTagged);
 }

 void TestLargeFrame(const char* type,
                     const char* zero,
                     const char* one,
                     const char* main) {
   SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 1000);
   TextBuffer printer(256 * KB);

   intptr_t num_locals = 2000;
   printer.Printf("import 'dart:typed_data';\n");
   printer.Printf("@pragma('vm:never-inline')\n");
   printer.Printf("%s one() { return %s; }\n", type, one);
   printer.Printf("@pragma('vm:never-inline')\n");
   printer.Printf("%s largeFrame(int n) {\n", type);
   for (intptr_t i = 0; i < num_locals; i++) {
     printer.Printf("  %s local%" Pd " = %s;\n", type, i, zero);
   }
   printer.Printf("  for (int i = 0; i < n; i++) {\n");
   for (intptr_t i = 0; i < num_locals; i++) {
     printer.Printf("    local%" Pd " += one();\n", i);
   }
   printer.Printf("  }\n");
   printer.Printf("  %s sum = %s;\n", type, zero);
   for (intptr_t i = 0; i < num_locals; i++) {
     printer.Printf("    sum += local%" Pd ";\n", i);
   }
   printer.Printf("  return sum;\n");
   printer.Printf("}\n");

   printer.AddString(main);

   const auto& root_library = Library::Handle(LoadTestScript(printer.buffer()));
   Invoke(root_library, "main");
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Int) {
   TestLargeFrame("int", "0", "1",
                  "main() {\n"
                  "  for (var i = 0; i < 100; i++) {\n"
                  "    var r = largeFrame(1);\n"
                  "    if (r != 2000) throw r;\n"
                  "  }\n"
                  "  return 'Okay';\n"
                  "}\n");
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Double) {
   TestLargeFrame("double", "0.0", "1.0",
                  "main() {\n"
                  "  for (var i = 0; i < 100; i++) {\n"
                  "    var r = largeFrame(1);\n"
                  "    if (r != 2000.0) throw r;\n"
                  "  }\n"
                  "  return 'Okay';\n"
                  "}\n");
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Int32x4) {
   TestLargeFrame("Int32x4", "Int32x4(0, 0, 0, 0)", "Int32x4(1, 2, 3, 4)",
                  "main() {\n"
                  "  for (var i = 0; i < 100; i++) {\n"
                  "    var r = largeFrame(1);\n"
                  "    if (r.x != 2000) throw r;\n"
                  "    if (r.y != 4000) throw r;\n"
                  "    if (r.z != 6000) throw r;\n"
                  "    if (r.w != 8000) throw r;\n"
                  "  }\n"
                  "  return 'Okay';\n"
                  "}\n");
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Float32x4) {
   TestLargeFrame("Float32x4", "Float32x4(0.0, 0.0, 0.0, 0.0)",
                  "Float32x4(1.0, 2.0, 3.0, 4.0)",
                  "main() {\n"
                  "  for (var i = 0; i < 100; i++) {\n"
                  "    var r = largeFrame(1);\n"
                  "    if (r.x != 2000.0) throw r;\n"
                  "    if (r.y != 4000.0) throw r;\n"
                  "    if (r.z != 6000.0) throw r;\n"
                  "    if (r.w != 8000.0) throw r;\n"
                  "  }\n"
                  "  return 'Okay';\n"
                  "}\n");
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Float64x2) {
   TestLargeFrame("Float64x2", "Float64x2(0.0, 0.0)", "Float64x2(1.0, 2.0)",
                  "main() {\n"
                  "  for (var i = 0; i < 100; i++) {\n"
                  "    var r = largeFrame(1);\n"
                  "    if (r.x != 2000.0) throw r;\n"
                  "    if (r.y != 4000.0) throw r;\n"
                  "  }\n"
                  "  return 'Okay';\n"
                  "}\n");
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Double) {
   if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
     return;
   }

   const char* kScript = R"(
     double foo(double sum, int n) {
        if (sum == null) return 0.0;
        for (int i = 0; i < n; i++) {
           sum += 1.0;
        }
        return sum;
     }
     main() {
       foo(0.0, 10);
     }
   )";

   const auto& root_library = Library::Handle(LoadTestScript(kScript));
   const auto& function = Function::Handle(GetFunction(root_library, "foo"));

   Invoke(root_library, "main");

   TestPipeline pipeline(function, CompilerPass::kJIT);
   FlowGraph* flow_graph = pipeline.RunPasses({});

   auto entry = flow_graph->graph_entry()->normal_entry();
   ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                    ParallelMovesHandling::kSkip);

   RELEASE_ASSERT(cursor.TryMatch({
       kMatchAndMoveFunctionEntry,
   }));
   if (FLAG_sound_null_safety != kNullSafetyOptionStrong) {
     RELEASE_ASSERT(cursor.TryMatch({
         kMatchAndMoveBranchFalse,
         kMatchAndMoveTargetEntry,
     }));
   }
   RELEASE_ASSERT(cursor.TryMatch({
       kMatchAndMoveUnbox,  // outside of loop
       kMatchAndMoveCheckSmi,
       kMoveGlob,

       // Loop header
       kMatchAndMoveJoinEntry,
       kMatchAndMoveCheckStackOverflow,
       kMatchAndMoveBranchTrue,

       // Loop body
       kMatchAndMoveTargetEntry,
       kMatchAndMoveBinaryDoubleOp,
       kMatchAndMoveBinarySmiOp,
       kMatchAndMoveGoto,

       // Loop header, again
       kMatchAndMoveJoinEntry,
       kMatchAndMoveCheckStackOverflow,
       kMatchAndMoveBranchFalse,

       // After loop
       kMatchAndMoveTargetEntry,
       kMatchAndMoveBox,
       kMatchReturn,
   }));
 }

 static void TestPhiUnboxingHeuristicSimd(const char* script) {
   if (!FlowGraphCompiler::SupportsUnboxedSimd128()) {
     return;
   }

   const auto& root_library = Library::Handle(LoadTestScript(script));
   const auto& function = Function::Handle(GetFunction(root_library, "foo"));

   Invoke(root_library, "main");

   TestPipeline pipeline(function, CompilerPass::kJIT);
   FlowGraph* flow_graph = pipeline.RunPasses({});

   auto entry = flow_graph->graph_entry()->normal_entry();
   ILMatcher cursor(flow_graph, entry, /*trace=*/true,
                    ParallelMovesHandling::kSkip);

   RELEASE_ASSERT(cursor.TryMatch({
       kMatchAndMoveFunctionEntry,
   }));
   if (FLAG_sound_null_safety != kNullSafetyOptionStrong) {
     RELEASE_ASSERT(cursor.TryMatch({
         kMatchAndMoveBranchFalse,
         kMatchAndMoveTargetEntry,
     }));
   }
   RELEASE_ASSERT(cursor.TryMatch({
       kMatchAndMoveUnbox,  // outside of loop
       kMatchAndMoveCheckSmi,
       kMoveGlob,

       // Loop header
       kMatchAndMoveJoinEntry,
       kMatchAndMoveCheckStackOverflow,
       kMatchAndMoveBranchTrue,

       // Loop body
       kMatchAndMoveTargetEntry,
       kMatchAndMoveSimdOp,
       kMatchAndMoveBinarySmiOp,
       kMatchAndMoveGoto,

       // Loop header, again
       kMatchAndMoveJoinEntry,
       kMatchAndMoveCheckStackOverflow,
       kMatchAndMoveBranchFalse,

       // After loop
       kMatchAndMoveTargetEntry,
       kMatchAndMoveBox,
       kMatchReturn,
   }));
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Float32x4) {
   const char* kScript = R"(
     import 'dart:typed_data';
     Float32x4 foo(Float32x4 sum, int n) {
        if (sum == null) return Float32x4(0.0, 0.0, 0.0, 0.0);
        for (int i = 0; i < n; i++) {
           sum += Float32x4(1.0, 2.0, 3.0, 4.0);
        }
        return sum;
     }
     main() {
       foo(Float32x4(0.0, 0.0, 0.0, 0.0), 10);
     }
   )";
   TestPhiUnboxingHeuristicSimd(kScript);
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Float64x2) {
   const char* kScript = R"(
     import 'dart:typed_data';
     Float64x2 foo(Float64x2 sum, int n) {
        if (sum == null) return Float64x2(0.0, 0.0);
        for (int i = 0; i < n; i++) {
           sum += Float64x2(1.0, 2.0);
        }
        return sum;
     }
     main() {
       foo(Float64x2(0.0, 0.0), 10);
     }
   )";
   TestPhiUnboxingHeuristicSimd(kScript);
 }

 ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Int32x4) {
   const char* kScript = R"(
     import 'dart:typed_data';
     Int32x4 foo(Int32x4 sum, int n) {
        if (sum == null) return Int32x4(0, 0, 0, 0);
        for (int i = 0; i < n; i++) {
           sum += Int32x4(1, 2, 3, 4);
        }
        return sum;
     }
     main() {
       foo(Int32x4(0, 0, 0, 0), 10);
     }
   )";
   TestPhiUnboxingHeuristicSimd(kScript);
 }

 }  // namespace dart
	// Copyright (c) 2012, 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.

	#include "vm/compiler/backend/flow_graph.h"

	#include <vector>

	#include "platform/text_buffer.h"
	#include "platform/utils.h"
	#include "vm/compiler/backend/block_builder.h"
	#include "vm/compiler/backend/flow_graph_compiler.h"
	#include "vm/compiler/backend/il_printer.h"
	#include "vm/compiler/backend/il_test_helper.h"
	#include "vm/compiler/backend/type_propagator.h"
	#include "vm/unit_test.h"

	namespace dart {

	#if defined(TARGET_ARCH_IS_64_BIT)
	ISOLATE_UNIT_TEST_CASE(FlowGraph_UnboxInt64Phi) {
	using compiler::BlockBuilder;

	CompilerState S(thread, /is_aot=/true, /is_optimizing=/true);

	FlowGraphBuilderHelper H;

	// Add a variable into the scope which would provide static type for the
	// parameter.
	LocalVariable* v0_var =
	new LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
	String::Handle(Symbols::New(thread, "v0")),
	AbstractType::ZoneHandle(Type::IntType()),
	new CompileType(CompileType::Int()));
	v0_var->set_type_check_mode(LocalVariable::kTypeCheckedByCaller);
	H.flow_graph()->parsed_function().scope()->AddVariable(v0_var);

	auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
	auto loop_header = H.JoinEntry();
	auto loop_body = H.TargetEntry();
	auto loop_exit = H.TargetEntry();

	Definition* v0;
	PhiInstr* loop_var;
	Definition* add1;

	{
	BlockBuilder builder(H.flow_graph(), normal_entry);
	v0 = builder.AddParameter(0, 0, /with_frame=/true, kTagged);
	builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
	}

	{
	BlockBuilder builder(H.flow_graph(), loop_header);
	loop_var = H.Phi(loop_header, {{normal_entry, v0}, {loop_body, &add1}});
	builder.AddPhi(loop_var);
	builder.AddBranch(new RelationalOpInstr(
	InstructionSource(), Token::kLT, new Value(loop_var),
	new Value(H.IntConstant(50)), kMintCid,
	S.GetNextDeoptId(), Instruction::kNotSpeculative),
	loop_body, loop_exit);
	}

	{
	BlockBuilder builder(H.flow_graph(), loop_body);
	add1 = builder.AddDefinition(new BinaryInt64OpInstr(
	Token::kADD, new Value(loop_var), new Value(H.IntConstant(1)),
	S.GetNextDeoptId(), Instruction::kNotSpeculative));
	builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
	}

	{
	BlockBuilder builder(H.flow_graph(), loop_exit);
	builder.AddReturn(new Value(loop_var));
	}

	H.FinishGraph();

	FlowGraphTypePropagator::Propagate(H.flow_graph());
	H.flow_graph()->SelectRepresentations();

	EXPECT_PROPERTY(loop_var, it.representation() == kUnboxedInt64);
	}
	#endif // defined(TARGET_ARCH_IS_64_BIT)

	ISOLATE_UNIT_TEST_CASE(FlowGraph_LateVariablePhiUnboxing) {
	using compiler::BlockBuilder;

	CompilerState S(thread, /is_aot=/true, /is_optimizing=/true);
	FlowGraphBuilderHelper H;

	auto normal_entry = H.flow_graph()->graph_entry()->normal_entry();
	auto loop_header = H.JoinEntry();
	auto loop_body = H.TargetEntry();
	auto loop_exit = H.TargetEntry();

	ConstantInstr* sentinel = H.flow_graph()->GetConstant(Object::sentinel());

	PhiInstr* loop_var;
	PhiInstr* late_var;
	Definition* add1;

	{
	BlockBuilder builder(H.flow_graph(), normal_entry);
	builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
	}

	{
	BlockBuilder builder(H.flow_graph(), loop_header);
	loop_var = H.Phi(loop_header,
	{{normal_entry, H.IntConstant(0)}, {loop_body, &add1}});
	builder.AddPhi(loop_var);
	loop_var->UpdateType(CompileType::Int());
	loop_var->UpdateType(CompileType::FromAbstractType(
	Type::ZoneHandle(Type::IntType()), CompileType::kCannotBeNull,
	CompileType::kCanBeSentinel));
	late_var =
	H.Phi(loop_header, {{normal_entry, sentinel}, {loop_body, &add1}});
	builder.AddPhi(late_var);
	builder.AddBranch(new RelationalOpInstr(
	InstructionSource(), Token::kLT, new Value(loop_var),
	new Value(H.IntConstant(10)), kMintCid,
	S.GetNextDeoptId(), Instruction::kNotSpeculative),
	loop_body, loop_exit);
	}

	{
	BlockBuilder builder(H.flow_graph(), loop_body);
	add1 = builder.AddDefinition(new BinaryInt64OpInstr(
	Token::kADD, new Value(loop_var), new Value(H.IntConstant(1)),
	S.GetNextDeoptId(), Instruction::kNotSpeculative));
	builder.AddInstruction(new GotoInstr(loop_header, S.GetNextDeoptId()));
	}

	{
	BlockBuilder builder(H.flow_graph(), loop_exit);
	builder.AddReturn(new Value(late_var));
	}

	H.FinishGraph();

	FlowGraphTypePropagator::Propagate(H.flow_graph());
	H.flow_graph()->SelectRepresentations();

	#if defined(TARGET_ARCH_IS_64_BIT)
	EXPECT_PROPERTY(loop_var, it.representation() == kUnboxedInt64);
	#endif
	EXPECT_PROPERTY(late_var, it.representation() == kTagged);
	}

	void TestLargeFrame(const char* type,
	const char* zero,
	const char* one,
	const char* main) {
	SetFlagScope<int> sfs(&FLAG_optimization_counter_threshold, 1000);
	TextBuffer printer(256 * KB);

	intptr_t num_locals = 2000;
	printer.Printf("import 'dart:typed_data';\n");
	printer.Printf("@pragma('vm:never-inline')\n");
	printer.Printf("%s one() { return %s; }\n", type, one);
	printer.Printf("@pragma('vm:never-inline')\n");
	printer.Printf("%s largeFrame(int n) {\n", type);
	for (intptr_t i = 0; i < num_locals; i++) {
	printer.Printf(" %s local%" Pd " = %s;\n", type, i, zero);
	}
	printer.Printf(" for (int i = 0; i < n; i++) {\n");
	for (intptr_t i = 0; i < num_locals; i++) {
	printer.Printf(" local%" Pd " += one();\n", i);
	}
	printer.Printf(" }\n");
	printer.Printf(" %s sum = %s;\n", type, zero);
	for (intptr_t i = 0; i < num_locals; i++) {
	printer.Printf(" sum += local%" Pd ";\n", i);
	}
	printer.Printf(" return sum;\n");
	printer.Printf("}\n");

	printer.AddString(main);

	const auto& root_library = Library::Handle(LoadTestScript(printer.buffer()));
	Invoke(root_library, "main");
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Int) {
	TestLargeFrame("int", "0", "1",
	"main() {\n"
	" for (var i = 0; i < 100; i++) {\n"
	" var r = largeFrame(1);\n"
	" if (r != 2000) throw r;\n"
	" }\n"
	" return 'Okay';\n"
	"}\n");
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Double) {
	TestLargeFrame("double", "0.0", "1.0",
	"main() {\n"
	" for (var i = 0; i < 100; i++) {\n"
	" var r = largeFrame(1);\n"
	" if (r != 2000.0) throw r;\n"
	" }\n"
	" return 'Okay';\n"
	"}\n");
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Int32x4) {
	TestLargeFrame("Int32x4", "Int32x4(0, 0, 0, 0)", "Int32x4(1, 2, 3, 4)",
	"main() {\n"
	" for (var i = 0; i < 100; i++) {\n"
	" var r = largeFrame(1);\n"
	" if (r.x != 2000) throw r;\n"
	" if (r.y != 4000) throw r;\n"
	" if (r.z != 6000) throw r;\n"
	" if (r.w != 8000) throw r;\n"
	" }\n"
	" return 'Okay';\n"
	"}\n");
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Float32x4) {
	TestLargeFrame("Float32x4", "Float32x4(0.0, 0.0, 0.0, 0.0)",
	"Float32x4(1.0, 2.0, 3.0, 4.0)",
	"main() {\n"
	" for (var i = 0; i < 100; i++) {\n"
	" var r = largeFrame(1);\n"
	" if (r.x != 2000.0) throw r;\n"
	" if (r.y != 4000.0) throw r;\n"
	" if (r.z != 6000.0) throw r;\n"
	" if (r.w != 8000.0) throw r;\n"
	" }\n"
	" return 'Okay';\n"
	"}\n");
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Float64x2) {
	TestLargeFrame("Float64x2", "Float64x2(0.0, 0.0)", "Float64x2(1.0, 2.0)",
	"main() {\n"
	" for (var i = 0; i < 100; i++) {\n"
	" var r = largeFrame(1);\n"
	" if (r.x != 2000.0) throw r;\n"
	" if (r.y != 4000.0) throw r;\n"
	" }\n"
	" return 'Okay';\n"
	"}\n");
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Double) {
	if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
	return;
	}

	const char* kScript = R"(
	double foo(double sum, int n) {
	if (sum == null) return 0.0;
	for (int i = 0; i < n; i++) {
	sum += 1.0;
	}
	return sum;
	}
	main() {
	foo(0.0, 10);
	}
	)";

	const auto& root_library = Library::Handle(LoadTestScript(kScript));
	const auto& function = Function::Handle(GetFunction(root_library, "foo"));

	Invoke(root_library, "main");

	TestPipeline pipeline(function, CompilerPass::kJIT);
	FlowGraph* flow_graph = pipeline.RunPasses({});

	auto entry = flow_graph->graph_entry()->normal_entry();
	ILMatcher cursor(flow_graph, entry, /trace=/true,
	ParallelMovesHandling::kSkip);

	RELEASE_ASSERT(cursor.TryMatch({
	kMatchAndMoveFunctionEntry,
	}));
	if (FLAG_sound_null_safety != kNullSafetyOptionStrong) {
	RELEASE_ASSERT(cursor.TryMatch({
	kMatchAndMoveBranchFalse,
	kMatchAndMoveTargetEntry,
	}));
	}
	RELEASE_ASSERT(cursor.TryMatch({
	kMatchAndMoveUnbox, // outside of loop
	kMatchAndMoveCheckSmi,
	kMoveGlob,

	// Loop header
	kMatchAndMoveJoinEntry,
	kMatchAndMoveCheckStackOverflow,
	kMatchAndMoveBranchTrue,

	// Loop body
	kMatchAndMoveTargetEntry,
	kMatchAndMoveBinaryDoubleOp,
	kMatchAndMoveBinarySmiOp,
	kMatchAndMoveGoto,

	// Loop header, again
	kMatchAndMoveJoinEntry,
	kMatchAndMoveCheckStackOverflow,
	kMatchAndMoveBranchFalse,

	// After loop
	kMatchAndMoveTargetEntry,
	kMatchAndMoveBox,
	kMatchReturn,
	}));
	}

	static void TestPhiUnboxingHeuristicSimd(const char* script) {
	if (!FlowGraphCompiler::SupportsUnboxedSimd128()) {
	return;
	}

	const auto& root_library = Library::Handle(LoadTestScript(script));
	const auto& function = Function::Handle(GetFunction(root_library, "foo"));

	Invoke(root_library, "main");

	TestPipeline pipeline(function, CompilerPass::kJIT);
	FlowGraph* flow_graph = pipeline.RunPasses({});

	auto entry = flow_graph->graph_entry()->normal_entry();
	ILMatcher cursor(flow_graph, entry, /trace=/true,
	ParallelMovesHandling::kSkip);

	RELEASE_ASSERT(cursor.TryMatch({
	kMatchAndMoveFunctionEntry,
	}));
	if (FLAG_sound_null_safety != kNullSafetyOptionStrong) {
	RELEASE_ASSERT(cursor.TryMatch({
	kMatchAndMoveBranchFalse,
	kMatchAndMoveTargetEntry,
	}));
	}
	RELEASE_ASSERT(cursor.TryMatch({
	kMatchAndMoveUnbox, // outside of loop
	kMatchAndMoveCheckSmi,
	kMoveGlob,

	// Loop header
	kMatchAndMoveJoinEntry,
	kMatchAndMoveCheckStackOverflow,
	kMatchAndMoveBranchTrue,

	// Loop body
	kMatchAndMoveTargetEntry,
	kMatchAndMoveSimdOp,
	kMatchAndMoveBinarySmiOp,
	kMatchAndMoveGoto,

	// Loop header, again
	kMatchAndMoveJoinEntry,
	kMatchAndMoveCheckStackOverflow,
	kMatchAndMoveBranchFalse,

	// After loop
	kMatchAndMoveTargetEntry,
	kMatchAndMoveBox,
	kMatchReturn,
	}));
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Float32x4) {
	const char* kScript = R"(
	import 'dart:typed_data';
	Float32x4 foo(Float32x4 sum, int n) {
	if (sum == null) return Float32x4(0.0, 0.0, 0.0, 0.0);
	for (int i = 0; i < n; i++) {
	sum += Float32x4(1.0, 2.0, 3.0, 4.0);
	}
	return sum;
	}
	main() {
	foo(Float32x4(0.0, 0.0, 0.0, 0.0), 10);
	}
	)";
	TestPhiUnboxingHeuristicSimd(kScript);
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Float64x2) {
	const char* kScript = R"(
	import 'dart:typed_data';
	Float64x2 foo(Float64x2 sum, int n) {
	if (sum == null) return Float64x2(0.0, 0.0);
	for (int i = 0; i < n; i++) {
	sum += Float64x2(1.0, 2.0);
	}
	return sum;
	}
	main() {
	foo(Float64x2(0.0, 0.0), 10);
	}
	)";
	TestPhiUnboxingHeuristicSimd(kScript);
	}

	ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Int32x4) {
	const char* kScript = R"(
	import 'dart:typed_data';
	Int32x4 foo(Int32x4 sum, int n) {
	if (sum == null) return Int32x4(0, 0, 0, 0);
	for (int i = 0; i < n; i++) {
	sum += Int32x4(1, 2, 3, 4);
	}
	return sum;
	}
	main() {
	foo(Int32x4(0, 0, 0, 0), 10);
	}
	)";
	TestPhiUnboxingHeuristicSimd(kScript);
	}

	} // namespace dart