[vm] `FlowGraphCompiler::EmitMove` does not support kUnboxedFloat from const source to stack

[dcharkes]

For const moves, it uses the constant instruction:

sdk/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc

Lines 906 to 916 in 5403dc4

	ASSERT(source.IsConstant());
	if (destination.IsFpuRegister() || destination.IsDoubleStackSlot() ||
	destination.IsStackSlot()) {
	Register tmp = allocator->AllocateTemporary();
	source.constant_instruction()->EmitMoveToLocation(this, destination, tmp,
	source.pair_index());
	allocator->ReleaseTemporary();
	} else {
	source.constant_instruction()->EmitMoveToLocation(
	this, destination, kNoRegister, source.pair_index());
	}

And this instruction doesn't support kUnboxedFloat, and silently does the wrong thing on some archs:

Silent failure on arm32, assuming kTagged:

sdk/runtime/vm/compiler/backend/il_arm.cc

Lines 903 to 917 in 5403dc4

	} else {
	ASSERT(destination.IsStackSlot());
	ASSERT(tmp != kNoRegister);
	const intptr_t dest_offset = destination.ToStackSlotOffset();
	if (RepresentationUtils::IsUnboxedInteger(representation())) {
	int64_t v;
	const bool ok = compiler::HasIntegerValue(value_, &v);
	RELEASE_ASSERT(ok);
	__ LoadImmediate(
	tmp, pair_index == 0 ? Utils::Low32Bits(v) : Utils::High32Bits(v));
	} else {
	__ LoadObject(tmp, value_);
	}
	__ StoreToOffset(tmp, destination.base_reg(), dest_offset);
	}

Discovered on https://dart-review.googlesource.com/c/sdk/+/284300/59

[dcharkes]

Our IL tests don't give us access to the assembler. Our assembler tests don't have a flow graph. There is actually no need for ConstantInstr::EmitMoveToLocation to take a FlowGraphCompiler as argument, it only uses the Assembler. However, then we'd lose the parallel with all EmitNativeCode methods. And it would subsequently make more sense to move the implementation into the assemblers instead of the il_xx.cc files.

Not sure if that refactoring would be worth it.

[dcharkes]

So far the Assembler does not depend on Location. (And introducing that dependency currently creates an import cycle between the header files.)

The assembler is context agnostic, e.g. it doesn't know about IL, the FlowGraph, etc.
Location is mostly context agnostic. However, constant locations refer to a ConstantInstr which encapsulates the actual value and representation.
If we ignore the constant locations being backed by an instruction, then the target destination of a move is completely context agnostic, and we could have destination locations in the assembler.
(Thanks @sstrickl for some of these observations!)

[dcharkes]

CL without refactoring: https://dart-review.googlesource.com/c/sdk/+/332761