Initial SIMDBC interpreter.

runtime/vm/flow_graph_compiler.h

 // 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.
 
 #ifndef VM_FLOW_GRAPH_COMPILER_H_
 #define VM_FLOW_GRAPH_COMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
@@ skipping 349 matching lines @@
   void CompileGraph();
 
   void VisitBlocks();
 
   // Bail out of the flow graph compiler. Does not return to the caller.
   void Bailout(const char* reason);
 
   // Returns 'true' if regular code generation should be skipped.
   bool TryIntrinsify();
 
+  void GenerateAssertAssignable(TokenPosition token_pos,
+                                intptr_t deopt_id,
+                                const AbstractType& dst_type,
+                                const String& dst_name,
+                                LocationSummary* locs);
+
+  // DBC emits calls very differently from all other architectures due to its

[zra, 2016/04/14 18:27:48]

I'd leave these in and put UNREACHABLE() or similar in the implementation. The
failure mode here if one of these gets called is a compiler error, which
probably won't actually be easy to interpret. A runtime error could give more
information, and then you can also get a stack trace to see how the bad call is
reached.

[Florian Schneider, 2016/04/15 01:17:28]

I disagree. If we want to avoid the #ifdef here, one alternative could maybe be
to leave declarations in, but omit definitions, so that a use will result in a
linker error which would be fine as well.

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

I am with Florian on this one. I think making them UNREACHABLE is worse because
it leaves dead code behind. I want to explicitly know which parts of pipeline
are used and which ones are not. 

+  // interpreted nature.
+#if !defined(TARGET_ARCH_DBC)
   void GenerateRuntimeCall(TokenPosition token_pos,
                            intptr_t deopt_id,
                            const RuntimeEntry& entry,
                            intptr_t argument_count,
                            LocationSummary* locs);
 
   void GenerateCall(TokenPosition token_pos,
                     const StubEntry& stub_entry,
                     RawPcDescriptors::Kind kind,
                     LocationSummary* locs);
 
   void GenerateDartCall(intptr_t deopt_id,
                         TokenPosition token_pos,
                         const StubEntry& stub_entry,
                         RawPcDescriptors::Kind kind,
                         LocationSummary* locs);
   void GenerateStaticDartCall(intptr_t deopt_id,
                               TokenPosition token_pos,
                               const StubEntry& stub_entry,
                               RawPcDescriptors::Kind kind,
                               LocationSummary* locs,
                               const Function& target);
 
-  void GenerateAssertAssignable(TokenPosition token_pos,
-                                intptr_t deopt_id,
-                                const AbstractType& dst_type,
-                                const String& dst_name,
-                                LocationSummary* locs);
-
   void GenerateInstanceOf(TokenPosition token_pos,
                           intptr_t deopt_id,
                           const AbstractType& type,
                           bool negate_result,
                           LocationSummary* locs);
 
   void GenerateInstanceCall(intptr_t deopt_id,
                             TokenPosition token_pos,
                             intptr_t argument_count,
                             LocationSummary* locs,
@@ skipping 10 matching lines @@
   void GenerateNumberTypeCheck(Register kClassIdReg,
                                const AbstractType& type,
                                Label* is_instance_lbl,
                                Label* is_not_instance_lbl);
   void GenerateStringTypeCheck(Register kClassIdReg,
                                Label* is_instance_lbl,
                                Label* is_not_instance_lbl);
   void GenerateListTypeCheck(Register kClassIdReg,
                              Label* is_instance_lbl);
 
-  void EmitComment(Instruction* instr);
-
-  bool NeedsEdgeCounter(TargetEntryInstr* block);
-
-  void EmitEdgeCounter(intptr_t edge_id);
-
   void EmitOptimizedInstanceCall(const StubEntry& stub_entry,
                                  const ICData& ic_data,
                                  intptr_t argument_count,
                                  intptr_t deopt_id,
                                  TokenPosition token_pos,
                                  LocationSummary* locs);
 
   void EmitInstanceCall(const StubEntry& stub_entry,
                         const ICData& ic_data,
                         intptr_t argument_count,
@@ skipping 35 matching lines @@
 
   Condition EmitEqualityRegConstCompare(Register reg,
                                         const Object& obj,
                                         bool needs_number_check,
                                         TokenPosition token_pos);
   Condition EmitEqualityRegRegCompare(Register left,
                                       Register right,
                                       bool needs_number_check,
                                       TokenPosition token_pos);
 
+  bool NeedsEdgeCounter(TargetEntryInstr* block);
+
+  void EmitEdgeCounter(intptr_t edge_id);
+#endif

[zra, 2016/04/14 18:27:48]

add  // !defined(TARGET_ARCH_DBC)

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

Done.

+
   void EmitTrySync(Instruction* instr, intptr_t try_index);
 
+  void EmitComment(Instruction* instr);
+
+

[zra, 2016/04/14 18:27:48]

Extra space.

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

Done.

   intptr_t StackSize() const;
 
   // Returns assembler label associated with the given block entry.
   Label* GetJumpLabel(BlockEntryInstr* block_entry) const;
   bool WasCompacted(BlockEntryInstr* block_entry) const;
 
   // Returns the label of the fall-through of the current block.
   Label* NextNonEmptyLabel() const;
 
   // Returns true if there is a next block after the current one in
@@ skipping 126 matching lines @@
                                intptr_t deopt_id,
                                TokenPosition token_pos,
                                LocationSummary* locs);
 
   void EmitUnoptimizedStaticCall(intptr_t argument_count,
                                  intptr_t deopt_id,
                                  TokenPosition token_pos,
                                  LocationSummary* locs,
                                  const ICData& ic_data);
 
+  // DBC handles type tests differently from all other architectures due

[zra, 2016/04/14 18:27:48]

ditto.

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

Acknowledged.

+  // to its interpreted nature.
+#if !defined(TARGET_ARCH_DBC)
   // Type checking helper methods.
   void CheckClassIds(Register class_id_reg,
                      const GrowableArray<intptr_t>& class_ids,
                      Label* is_instance_lbl,
                      Label* is_not_instance_lbl);
 
   RawSubtypeTestCache* GenerateInlineInstanceof(TokenPosition token_pos,
                                                 const AbstractType& type,
                                                 Label* is_instance_lbl,
                                                 Label* is_not_instance_lbl);
@@ skipping 33 matching lines @@
                                                    Register temp_reg,
                                                    Label* is_instance_lbl,
                                                    Label* is_not_instance_lbl);
 
   // Returns true if checking against this type is a direct class id comparison.
   bool TypeCheckAsClassEquality(const AbstractType& type);
 
   void GenerateBoolToJump(Register bool_reg, Label* is_true, Label* is_false);
 
   void CopyParameters();
+#endif

[zra, 2016/04/14 18:27:48]

add  // !defined(TARGET_ARCH_DBC)

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

Done.

 
   void GenerateInlinedGetter(intptr_t offset);
   void GenerateInlinedSetter(intptr_t offset);
 
   // Perform a greedy local register allocation.  Consider all registers free.
   void AllocateRegistersLocally(Instruction* instr);
 
   // Map a block number in a forward iteration into the block number in the
   // corresponding reverse iteration.  Used to obtain an index into
   // block_order for reverse iterations.
@@ skipping 12 matching lines @@
 
   intptr_t GetOptimizationThreshold() const;
 
   StackmapTableBuilder* stackmap_table_builder() {
     if (stackmap_table_builder_ == NULL) {
       stackmap_table_builder_ = new StackmapTableBuilder();
     }
     return stackmap_table_builder_;
   }
 
-#if defined(DEBUG)
+#if defined(DEBUG) && !defined(TARGET_ARCH_DBC)

[zra, 2016/04/14 18:27:48]

ditto or add comment.

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

There is a comment in the CC code. Duplicated it here.

   void FrameStateUpdateWith(Instruction* instr);
   void FrameStatePush(Definition* defn);
   void FrameStatePop(intptr_t count);
   bool FrameStateIsSafeToCall();
   void FrameStateClear();
 #endif
 
   // This struct contains either function or code, the other one being NULL.
   class StaticCallsStruct : public ZoneAllocated {
    public:
@@ skipping 71 matching lines @@
   const GrowableArray<const Function*>& inline_id_to_function_;
   const GrowableArray<TokenPosition>& inline_id_to_token_pos_;
   const GrowableArray<intptr_t>& caller_inline_id_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphCompiler);
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_COMPILER_H_