Fix vm code base so that it can be built for --arch=simarm (no snapshot yet).

runtime/vm/flow_graph_compiler_arm.cc

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2013, 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/globals.h"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/longjump.h"
 
 namespace dart {
 
+bool FlowGraphCompiler::SupportsUnboxedMints() {
+  return false;
+}
+
+
+void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler,
+                                             intptr_t stub_ix) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::GenerateBoolToJump(Register bool_register,
+                                           Label* is_true,
+                                           Label* is_false) {
+  UNIMPLEMENTED();
+}
+
+
+RawSubtypeTestCache* FlowGraphCompiler::GenerateCallSubtypeTestStub(
+    TypeTestStubKind test_kind,
+    Register instance_reg,
+    Register type_arguments_reg,
+    Register temp_reg,
+    Label* is_instance_lbl,
+    Label* is_not_instance_lbl) {
+  UNIMPLEMENTED();
+  return NULL;
+}
+
+
+RawSubtypeTestCache*
+FlowGraphCompiler::GenerateInstantiatedTypeWithArgumentsTest(
+    intptr_t token_pos,
+    const AbstractType& type,
+    Label* is_instance_lbl,
+    Label* is_not_instance_lbl) {
+  UNIMPLEMENTED();
+  return NULL;
+}
+
+
+void FlowGraphCompiler::CheckClassIds(Register class_id_reg,
+                                      const GrowableArray<intptr_t>& class_ids,
+                                      Label* is_equal_lbl,
+                                      Label* is_not_equal_lbl) {
+  UNIMPLEMENTED();
+}
+
+
+bool FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
+    intptr_t token_pos,
+    const AbstractType& type,
+    Label* is_instance_lbl,
+    Label* is_not_instance_lbl) {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+RawSubtypeTestCache* FlowGraphCompiler::GenerateSubtype1TestCacheLookup(
+    intptr_t token_pos,
+    const Class& type_class,
+    Label* is_instance_lbl,
+    Label* is_not_instance_lbl) {
+  UNIMPLEMENTED();
+  return NULL;
+}
+
+
+RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest(
+    intptr_t token_pos,
+    const AbstractType& type,
+    Label* is_instance_lbl,
+    Label* is_not_instance_lbl) {
+  UNIMPLEMENTED();
+  return NULL;
+}
+
+
+RawSubtypeTestCache* FlowGraphCompiler::GenerateInlineInstanceof(
+    intptr_t token_pos,
+    const AbstractType& type,
+    Label* is_instance_lbl,
+    Label* is_not_instance_lbl) {
+  UNIMPLEMENTED();
+  return NULL;
+}
+
+
+void FlowGraphCompiler::GenerateInstanceOf(intptr_t token_pos,
+                                           const AbstractType& type,
+                                           bool negate_result,
+                                           LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::GenerateAssertAssignable(intptr_t token_pos,
+                                                 const AbstractType& dst_type,
+                                                 const String& dst_name,
+                                                 LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitInstructionPrologue(Instruction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::CopyParameters() {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitFrameEntry() {
+  UNIMPLEMENTED();
+}
+
+
 void FlowGraphCompiler::CompileGraph() {
   UNIMPLEMENTED();
 }
 
 
-void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
-  UNIMPLEMENTED();
-}
-
-
-void FlowGraphCompiler::FinalizeStackmaps(const Code& code) {
-  UNIMPLEMENTED();
-}
-
-
-void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
-  UNIMPLEMENTED();
-}
-
-
-void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
-  UNIMPLEMENTED();
-}
-
-
-void FlowGraphCompiler::FinalizeComments(const Code& code) {
-  UNIMPLEMENTED();
-}
+void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
+                                     const ExternalLabel* label,
+                                     PcDescriptors::Kind kind,
+                                     LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::GenerateDartCall(intptr_t deopt_id,
+                                         intptr_t token_pos,
+                                         const ExternalLabel* label,
+                                         PcDescriptors::Kind kind,
+                                         LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::GenerateCallRuntime(intptr_t token_pos,
+                                            const RuntimeEntry& entry,
+                                            LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitOptimizedInstanceCall(
+    ExternalLabel* target_label,
+    const ICData& ic_data,
+    const Array& arguments_descriptor,
+    intptr_t argument_count,
+    intptr_t deopt_id,
+    intptr_t token_pos,
+    LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
+                                         const ICData& ic_data,
+                                         const Array& arguments_descriptor,
+                                         intptr_t argument_count,
+                                         intptr_t deopt_id,
+                                         intptr_t token_pos,
+                                         LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitMegamorphicInstanceCall(
+    const ICData& ic_data,
+    const Array& arguments_descriptor,
+    intptr_t argument_count,
+    intptr_t deopt_id,
+    intptr_t token_pos,
+    LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitStaticCall(const Function& function,
+                                       const Array& arguments_descriptor,
+                                       intptr_t argument_count,
+                                       intptr_t deopt_id,
+                                       intptr_t token_pos,
+                                       LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitEqualityRegConstCompare(Register reg,
+                                                    const Object& obj,
+                                                    bool needs_number_check) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitEqualityRegRegCompare(Register left,
+                                                  Register right,
+                                                  bool needs_number_check) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitSuperEqualityCallPrologue(Register result,
+                                                      Label* skip_call) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::SaveLiveRegisters(LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::RestoreLiveRegisters(LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitTestAndCall(const ICData& ic_data,
+                                        Register class_id_reg,
+                                        intptr_t arg_count,
+                                        const Array& arg_names,
+                                        Label* deopt,
+                                        intptr_t deopt_id,
+                                        intptr_t token_index,
+                                        LocationSummary* locs) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitDoubleCompareBranch(Condition true_condition,
+                                                FpuRegister left,
+                                                FpuRegister right,
+                                                BranchInstr* branch) {
+  UNIMPLEMENTED();
+}
+
+
+void FlowGraphCompiler::EmitDoubleCompareBool(Condition true_condition,
+                                              FpuRegister left,
+                                              FpuRegister right,
+                                              Register result) {
+  UNIMPLEMENTED();
+}
+
+
+Condition FlowGraphCompiler::FlipCondition(Condition condition) {
+  UNIMPLEMENTED();
+  return condition;
+}
+
+
+bool FlowGraphCompiler::EvaluateCondition(Condition condition,
+                                          intptr_t left,
+                                          intptr_t right) {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+FieldAddress FlowGraphCompiler::ElementAddressForIntIndex(intptr_t cid,
+                                                          Register array,
+                                                          intptr_t index) {
+  UNIMPLEMENTED();
+  return FieldAddress(array, index);
+}
+
+
+FieldAddress FlowGraphCompiler::ElementAddressForRegIndex(intptr_t cid,
+                                                          Register array,
+                                                          Register index) {
+  UNIMPLEMENTED();
+  return FieldAddress(array, index);
+}
+
+
+void ParallelMoveResolver::EmitMove(int index) {
+  UNIMPLEMENTED();
+}
+
+
+void ParallelMoveResolver::EmitSwap(int index) {
+  UNIMPLEMENTED();
+}
+
+
+void ParallelMoveResolver::MoveMemoryToMemory(const Address& dst,
+                                              const Address& src) {
+  UNIMPLEMENTED();
+}
+
+
+void ParallelMoveResolver::StoreObject(const Address& dst, const Object& obj) {
+  UNIMPLEMENTED();
+}
+
+
+void ParallelMoveResolver::Exchange(Register reg, const Address& mem) {
+  UNIMPLEMENTED();
+}
+
+
+void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
+  UNIMPLEMENTED();
+}
+
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM