clang-format runtime/vm

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 RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 #define RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
 #include "vm/code_generator.h"
 #include "vm/intermediate_language.h"
 
 namespace dart {
 
 // Forward declarations.
 class Code;
 class DeoptInfoBuilder;
 class FlowGraph;
 class FlowGraphCompiler;
 class Function;
-template <typename T> class GrowableArray;
+template <typename T>
+class GrowableArray;
 class ParsedFunction;
 
 
 class ParallelMoveResolver : public ValueObject {
  public:
   explicit ParallelMoveResolver(FlowGraphCompiler* compiler);
 
   // Resolve a set of parallel moves, emitting assembler instructions.
   void EmitNativeCode(ParallelMoveInstr* parallel_move);
 
@@ skipping 84 matching lines @@
                     ICData::DeoptReasonId reason,
                     uint32_t flags,
                     Environment* deopt_env)
       : pc_offset_(-1),
         deopt_id_(deopt_id),
         reason_(reason),
         flags_(flags),
         deopt_env_(deopt_env) {
     ASSERT(deopt_env != NULL);
   }
-  virtual ~CompilerDeoptInfo() { }
+  virtual ~CompilerDeoptInfo() {}
 
   RawTypedData* CreateDeoptInfo(FlowGraphCompiler* compiler,
                                 DeoptInfoBuilder* builder,
                                 const Array& deopt_table);
 
 
   // No code needs to be generated.
   virtual void GenerateCode(FlowGraphCompiler* compiler, intptr_t stub_ix) {}
 
   intptr_t pc_offset() const { return pc_offset_; }
@@ skipping 30 matching lines @@
     ASSERT(reason != ICData::kDeoptAtCall);
   }
 
   Label* entry_label() { return &entry_label_; }
 
   // Implementation is in architecture specific file.
   virtual void GenerateCode(FlowGraphCompiler* compiler, intptr_t stub_ix);
 
   const char* Name() const {
     const char* kFormat = "Deopt stub for id %d, reason: %s";
-    const intptr_t len = OS::SNPrint(NULL, 0, kFormat,
-        deopt_id(), DeoptReasonToCString(reason())) + 1;
+    const intptr_t len = OS::SNPrint(NULL, 0, kFormat, deopt_id(),
+                                     DeoptReasonToCString(reason())) +
+                         1;
     char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, kFormat,
-        deopt_id(), DeoptReasonToCString(reason()));
+    OS::SNPrint(chars, len, kFormat, deopt_id(),
+                DeoptReasonToCString(reason()));
     return chars;
   }
 
  private:
   Label entry_label_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerDeoptInfoWithStub);
 };
 
 
 class SlowPathCode : public ZoneAllocated {
  public:
-  SlowPathCode() : entry_label_(), exit_label_() { }
-  virtual ~SlowPathCode() { }
+  SlowPathCode() : entry_label_(), exit_label_() {}
+  virtual ~SlowPathCode() {}
 
   Label* entry_label() { return &entry_label_; }
   Label* exit_label() { return &exit_label_; }
 
   void GenerateCode(FlowGraphCompiler* compiler) {
     EmitNativeCode(compiler);
     ASSERT(entry_label_.IsBound());
   }
 
  private:
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
 
   Label entry_label_;
   Label exit_label_;
 
   DISALLOW_COPY_AND_ASSIGN(SlowPathCode);
 };
 
 
 struct CidTarget {
   intptr_t cid;
   Function* target;
   intptr_t count;
-  CidTarget(intptr_t cid_arg,
-            Function* target_arg,
-            intptr_t count_arg)
+  CidTarget(intptr_t cid_arg, Function* target_arg, intptr_t count_arg)
       : cid(cid_arg), target(target_arg), count(count_arg) {}
 };
 
 
 class FlowGraphCompiler : public ValueObject {
  private:
   class BlockInfo : public ZoneAllocated {
    public:
     BlockInfo()
         : block_label_(),
           jump_label_(&block_label_),
           next_nonempty_label_(NULL),
           is_marked_(false) {}
 
     // The label to jump to when control is transferred to this block.  For
     // nonempty blocks it is the label of the block itself.  For empty
     // blocks it is the label of the first nonempty successor block.
     Label* jump_label() const { return jump_label_; }
     void set_jump_label(Label* label) { jump_label_ = label; }
 
     // The label of the first nonempty block after this one in the block
     // order, or NULL if there is no nonempty block following this one.
     Label* next_nonempty_label() const { return next_nonempty_label_; }
     void set_next_nonempty_label(Label* label) { next_nonempty_label_ = label; }
 
-    bool WasCompacted() const {
-      return jump_label_ != &block_label_;
-    }
+    bool WasCompacted() const { return jump_label_ != &block_label_; }
 
     // Block compaction is recursive.  Block info for already-compacted
     // blocks is marked so as to avoid cycles in the graph.
     bool is_marked() const { return is_marked_; }
     void mark() { is_marked_ = true; }
 
    private:
     Label block_label_;
 
     Label* jump_label_;
     Label* next_nonempty_label_;
 
     bool is_marked_;
   };
 
  public:
-  FlowGraphCompiler(
-      Assembler* assembler,
-      FlowGraph* flow_graph,
-      const ParsedFunction& parsed_function,
-      bool is_optimizing,
-      const GrowableArray<const Function*>& inline_id_to_function,
-      const GrowableArray<TokenPosition>& inline_id_to_token_pos,
-      const GrowableArray<intptr_t>& caller_inline_id);
+  FlowGraphCompiler(Assembler* assembler,
+                    FlowGraph* flow_graph,
+                    const ParsedFunction& parsed_function,
+                    bool is_optimizing,
+                    const GrowableArray<const Function*>& inline_id_to_function,
+                    const GrowableArray<TokenPosition>& inline_id_to_token_pos,
+                    const GrowableArray<intptr_t>& caller_inline_id);
 
   ~FlowGraphCompiler();
 
   static bool SupportsUnboxedDoubles();
   static bool SupportsUnboxedMints();
   static bool SupportsSinCos();
   static bool SupportsUnboxedSimd128();
   static bool SupportsHardwareDivision();
   static bool CanConvertUnboxedMintToDouble();
 
   static bool IsUnboxedField(const Field& field);
   static bool IsPotentialUnboxedField(const Field& field);
 
   // Accessors.
   Assembler* assembler() const { return assembler_; }
   const ParsedFunction& parsed_function() const { return parsed_function_; }
   const GrowableArray<BlockEntryInstr*>& block_order() const {
     return block_order_;
   }
 
   const FlowGraph& flow_graph() const { return flow_graph_; }
 
-  DescriptorList* pc_descriptors_list() const {
-    return pc_descriptors_list_;
-  }
+  DescriptorList* pc_descriptors_list() const { return pc_descriptors_list_; }
   BlockEntryInstr* current_block() const { return current_block_; }
-  void set_current_block(BlockEntryInstr* value) {
-    current_block_ = value;
-  }
+  void set_current_block(BlockEntryInstr* value) { current_block_ = value; }
   static bool CanOptimize();
   bool CanOptimizeFunction() const;
   bool CanOSRFunction() const;
   bool is_optimizing() const { return is_optimizing_; }
 
   void EnterIntrinsicMode();
   void ExitIntrinsicMode();
   bool intrinsic_mode() const { return intrinsic_mode_; }
 
-  Label* intrinsic_slow_path_label() {
-    return &intrinsic_slow_path_label_;
-  }
+  Label* intrinsic_slow_path_label() { return &intrinsic_slow_path_label_; }
 
   bool ForceSlowPathForStackOverflow() const;
 
   const GrowableArray<BlockInfo*>& block_info() const { return block_info_; }
   ParallelMoveResolver* parallel_move_resolver() {
     return &parallel_move_resolver_;
   }
 
   // Constructor is lighweight, major initialization work should occur here.
   // This makes it easier to measure time spent in the compiler.
   void InitCompiler();
 
   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
-  // interpreted nature.
+// DBC emits calls very differently from all other architectures due to its
+// 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,
@@ skipping 31 matching lines @@
                           LocationSummary* locs,
                           const ICData& ic_data);
 
   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 GenerateListTypeCheck(Register kClassIdReg, Label* is_instance_lbl);
 
   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,
                         intptr_t deopt_id,
                         TokenPosition token_pos,
                         LocationSummary* locs);
 
   void EmitPolymorphicInstanceCall(const ICData& ic_data,
                                    intptr_t argument_count,
                                    const Array& argument_names,
                                    intptr_t deopt_id,
                                    TokenPosition token_pos,
                                    LocationSummary* locs,
                                    bool complete);
 
   // Pass a value for try-index where block is not available (e.g. slow path).
-  void EmitMegamorphicInstanceCall(
-      const ICData& ic_data,
-      intptr_t argument_count,
-      intptr_t deopt_id,
-      TokenPosition token_pos,
-      LocationSummary* locs,
-      intptr_t try_index,
-      intptr_t slow_path_argument_count = 0);
+  void EmitMegamorphicInstanceCall(const ICData& ic_data,
+                                   intptr_t argument_count,
+                                   intptr_t deopt_id,
+                                   TokenPosition token_pos,
+                                   LocationSummary* locs,
+                                   intptr_t try_index,
+                                   intptr_t slow_path_argument_count = 0);
 
   void EmitSwitchableInstanceCall(const ICData& ic_data,
                                   intptr_t argument_count,
                                   intptr_t deopt_id,
                                   TokenPosition token_pos,
                                   LocationSummary* locs);
 
   void EmitTestAndCall(const ICData& ic_data,
                        intptr_t arg_count,
                        const Array& arg_names,
@@ skipping 123 matching lines @@
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
   Zone* zone() const { return zone_; }
 
   void AddStubCallTarget(const Code& code);
 
   const Array& inlined_code_intervals() const {
     return inlined_code_intervals_;
   }
 
-  RawArray* edge_counters_array() const {
-    return edge_counters_array_.raw();
-  }
+  RawArray* edge_counters_array() const { return edge_counters_array_.raw(); }
 
   RawArray* InliningIdToFunction() const;
   RawArray* InliningIdToTokenPos() const;
   RawArray* CallerInliningIdMap() const;
 
   CodeSourceMapBuilder* code_source_map_builder() {
     if (code_source_map_builder_ == NULL) {
       code_source_map_builder_ = new CodeSourceMapBuilder();
     }
     ASSERT(code_source_map_builder_ != NULL);
@@ skipping 30 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
-  // to its interpreted nature.
+// DBC handles type tests differently from all other architectures due
+// 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,
@@ skipping 64 matching lines @@
 
   intptr_t GetOptimizationThreshold() const;
 
   StackmapTableBuilder* stackmap_table_builder() {
     if (stackmap_table_builder_ == NULL) {
       stackmap_table_builder_ = new StackmapTableBuilder();
     }
     return stackmap_table_builder_;
   }
 
-  // TODO(vegorov) re-enable frame state tracking on DBC. It is
-  // currently disabled because it relies on LocationSummaries and
-  // we don't use them during unoptimized compilation on DBC.
+// TODO(vegorov) re-enable frame state tracking on DBC. It is
+// currently disabled because it relies on LocationSummaries and
+// we don't use them during unoptimized compilation on DBC.
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
   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 {
@@ skipping 70 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  // RUNTIME_VM_FLOW_GRAPH_COMPILER_H_