Move RMA::Label out of the class, so it can be forward declared.

src/compiler/raw-machine-assembler.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_RAW_MACHINE_ASSEMBLER_H_
 #define V8_COMPILER_RAW_MACHINE_ASSEMBLER_H_
 
 #include "src/assembler.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operator.h"
 #include "src/factory.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class BasicBlock;
 class Schedule;
 
+
+class RawLabel {

[Michael Starzinger, 2015/11/27 17:10:27]

super-nit: Can we move this class down to the bottom of the file and only
forward-declare it here? Because I think the long description of what the RMA is
and how it works should stay at the top of this file, so that people see it when
they stumble into this file.

[vogelheim, 2015/11/27 17:21:14]

Done.

+ public:
+  RawLabel() : block_(NULL), used_(false), bound_(false) {}
+  ~RawLabel() { DCHECK(bound_ || !used_); }
+
+ private:
+  BasicBlock* block_;
+  bool used_;
+  bool bound_;
+  friend class RawMachineAssembler;
+  DISALLOW_COPY_AND_ASSIGN(RawLabel);
+};
+
+
 // The RawMachineAssembler produces a low-level IR graph. All nodes are wired
 // into a graph and also placed into a schedule immediately, hence subsequent
 // code generation can happen without the need for scheduling.
 //
 // In order to create a schedule on-the-fly, the assembler keeps track of basic
 // blocks by having one current basic block being populated and by referencing
 // other basic blocks through the use of labels.
 //
 // Also note that the generated graph is only valid together with the generated
 // schedule, using one without the other is invalid as the graph is inherently
 // non-schedulable due to missing control and effect dependencies.
 class RawMachineAssembler {
  public:
-  class Label {
-   public:
-    Label() : block_(NULL), used_(false), bound_(false) {}
-    ~Label() { DCHECK(bound_ || !used_); }
-
-   private:
-    BasicBlock* block_;
-    bool used_;
-    bool bound_;
-    friend class RawMachineAssembler;
-    DISALLOW_COPY_AND_ASSIGN(Label);
-  };
-
   RawMachineAssembler(Isolate* isolate, Graph* graph,
                       CallDescriptor* call_descriptor,
                       MachineType word = kMachPtr,
                       MachineOperatorBuilder::Flags flags =
                           MachineOperatorBuilder::Flag::kNoFlags);
   ~RawMachineAssembler() {}
 
   Isolate* isolate() const { return isolate_; }
   Graph* graph() const { return graph_; }
   Zone* zone() const { return graph()->zone(); }
@@ skipping 517 matching lines @@
                        MachineType arg5_type, MachineType arg6_type,
                        MachineType arg7_type, Node* function, Node* arg0,
                        Node* arg1, Node* arg2, Node* arg3, Node* arg4,
                        Node* arg5, Node* arg6, Node* arg7);
 
   // ===========================================================================
   // The following utility methods deal with control flow, hence might switch
   // the current basic block or create new basic blocks for labels.
 
   // Control flow.
-  void Goto(Label* label);
-  void Branch(Node* condition, Label* true_val, Label* false_val);
-  void Switch(Node* index, Label* default_label, int32_t* case_values,
-              Label** case_labels, size_t case_count);
+  void Goto(RawLabel* label);
+  void Branch(Node* condition, RawLabel* true_val, RawLabel* false_val);
+  void Switch(Node* index, RawLabel* default_label, int32_t* case_values,
+              RawLabel** case_labels, size_t case_count);
   void Return(Node* value);
   void Return(Node* v1, Node* v2);
   void Return(Node* v1, Node* v2, Node* v3);
-  void Bind(Label* label);
+  void Bind(RawLabel* label);
   void Deoptimize(Node* state);
 
   // Variables.
   Node* Phi(MachineType type, Node* n1, Node* n2) {
     return AddNode(common()->Phi(type, 2), n1, n2);
   }
   Node* Phi(MachineType type, Node* n1, Node* n2, Node* n3) {
     return AddNode(common()->Phi(type, 3), n1, n2, n3);
   }
   Node* Phi(MachineType type, Node* n1, Node* n2, Node* n3, Node* n4) {
@@ skipping 12 matching lines @@
   }
 
   template <class... TArgs>
   Node* AddNode(const Operator* op, Node* n1, TArgs... args) {
     Node* buffer[] = {n1, args...};
     return AddNode(op, sizeof...(args) + 1, buffer);
   }
 
  private:
   Node* MakeNode(const Operator* op, int input_count, Node** inputs);
-  BasicBlock* Use(Label* label);
-  BasicBlock* EnsureBlock(Label* label);
+  BasicBlock* Use(RawLabel* label);
+  BasicBlock* EnsureBlock(RawLabel* label);
   BasicBlock* CurrentBlock();
 
   Schedule* schedule() { return schedule_; }
   size_t parameter_count() const { return machine_sig()->parameter_count(); }
   const MachineSignature* machine_sig() const {
     return call_descriptor_->GetMachineSignature();
   }
 
   Isolate* isolate_;
   Graph* graph_;
   Schedule* schedule_;
   MachineOperatorBuilder machine_;
   CommonOperatorBuilder common_;
   CallDescriptor* call_descriptor_;
   NodeVector parameters_;
   BasicBlock* current_block_;
 
   DISALLOW_COPY_AND_ASSIGN(RawMachineAssembler);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_RAW_MACHINE_ASSEMBLER_H_