Added pass framework

The patch adds a Middle-End pass system and normalizes the current
 passes into the pass framework.

Passes have:
 - A start, work, and end functions.
 - A gate to determine to apply the pass.
 - Can provide a CFG dump folder.

mir_dataflow.cc, mir_graph.cc, mir_optimization.cc, ssa_transformation.cc:
 - Changed due to moving code into bb_optimizations.cc.
 - Moved certain functions from private to public due to needed from the passes.

pass.cc, pass.h:
 - Pass base class

pass_driver.cc, pass_driver.h:
 - The pass driver implementation.

frontend.cc:
 - Replace the function calls to the passes with the pass driver.

Change-Id: I88cd82efbf6499df9e6c7f135d7e294dd724a079
Signed-off-by: Jean Christophe Beyler <jean.christophe.beyler@intel.com>

1 files changed, 145 insertions, 0 deletions

diff --git a/compiler/dex/pass.h b/compiler/dex/pass.h
new file mode 100644
index 0000000000..c52ddf5f27
--- /dev/null
+++ b/compiler/dex/pass.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_DEX_PASS_H_
+#define ART_COMPILER_DEX_PASS_H_
+
+#include <string>
+
+namespace art {
+
+// Forward declarations.
+class BasicBlock;
+class CompilationUnit;
+class Pass;
+
+/**
+ * @brief OptimizationFlag is an enumeration to perform certain tasks for a given pass.
+ * @details Each enum should be a power of 2 to be correctly used.
+ */
+enum OptimizationFlag {
+};
+
+enum DataFlowAnalysisMode {
+  kAllNodes = 0,                           /**< @brief All nodes. */
+  kPreOrderDFSTraversal,                   /**< @brief Depth-First-Search / Pre-Order. */
+  kRepeatingPreOrderDFSTraversal,          /**< @brief Depth-First-Search / Repeating Pre-Order. */
+  kReversePostOrderDFSTraversal,           /**< @brief Depth-First-Search / Reverse Post-Order. */
+  kRepeatingPostOrderDFSTraversal,         /**< @brief Depth-First-Search / Repeating Post-Order. */
+  kRepeatingReversePostOrderDFSTraversal,  /**< @brief Depth-First-Search / Repeating Reverse Post-Order. */
+  kPostOrderDOMTraversal,                  /**< @brief Dominator tree / Post-Order. */
+};
+
+/**
+ * @class Pass
+ * @brief Pass is the Pass structure for the optimizations.
+ * @details The following structure has the different optimization passes that we are going to do.
+ */
+class Pass {
+ public:
+  Pass(const char *name, DataFlowAnalysisMode type, bool freed, const unsigned int f, const char *dump): pass_name_(name), traversal_type_(type), flags_(f), dump_cfg_folder_(dump) {
+  }
+
+  Pass(const char *name, const char *dump): pass_name_(name), traversal_type_(kAllNodes), flags_(0), dump_cfg_folder_(dump) {
+  }
+
+  explicit Pass(const char *name):pass_name_(name), traversal_type_(kAllNodes), flags_(0), dump_cfg_folder_("") {
+  }
+
+  Pass(const char *name, DataFlowAnalysisMode type, const char *dump):pass_name_(name), traversal_type_(type), flags_(false), dump_cfg_folder_(dump) {
+  }
+
+  virtual ~Pass() {}
+
+  virtual const char* GetName() const {
+    return pass_name_;
+  }
+
+  virtual DataFlowAnalysisMode GetTraversal() const {
+    return traversal_type_;
+  }
+
+  virtual bool GetFlag(OptimizationFlag flag) const {
+    return (flags_ & flag);
+  }
+
+  const char* GetDumpCFGFolder() const {return dump_cfg_folder_;}
+
+  /**
+   * @brief Gate for the pass: determines whether to execute the pass or not considering a CompilationUnit
+   * @param c_unit the CompilationUnit.
+   * @return whether or not to execute the pass
+   */
+  virtual bool Gate(const CompilationUnit *c_unit) const {
+    // Unused parameter.
+    UNUSED(c_unit);
+
+    // Base class says yes.
+    return true;
+  }
+
+  /**
+   * @brief Start of the pass: called before the WalkBasicBlocks function
+   * @param c_unit the considered CompilationUnit.
+   */
+  virtual void Start(CompilationUnit *c_unit) const {
+    // Unused parameter.
+    UNUSED(c_unit);
+  }
+
+  /**
+   * @brief End of the pass: called after the WalkBasicBlocks function
+   * @param c_unit the considered CompilationUnit.
+   */
+  virtual void End(CompilationUnit *c_unit) const {
+    // Unused parameter.
+    UNUSED(c_unit);
+  }
+
+  /**
+   * @brief Actually walk the BasicBlocks following a particular traversal type.
+   * @param c_unit the CompilationUnit.
+   * @param bb the BasicBlock.
+   * @return whether or not there is a change when walking the BasicBlock
+   */
+  virtual bool WalkBasicBlocks(CompilationUnit *c_unit, BasicBlock *bb) const {
+    // Unused parameters.
+    UNUSED(c_unit);
+    UNUSED(bb);
+
+    // BasicBlock did not change.
+    return false;
+  }
+
+ protected:
+  /** @brief The pass name: used for searching for a pass when running a particular pass or debugging. */
+  const char* const pass_name_;
+
+  /** @brief Type of traversal: determines the order to execute the pass on the BasicBlocks. */
+  const DataFlowAnalysisMode traversal_type_;
+
+  /** @brief Flags for additional directives: used to determine if a particular clean-up is necessary post pass. */
+  const unsigned int flags_;
+
+  /** @brief CFG Dump Folder: what sub-folder to use for dumping the CFGs post pass. */
+  const char* const dump_cfg_folder_;
+
+ private:
+  // In order to make the all passes not copy-friendly.
+  DISALLOW_COPY_AND_ASSIGN(Pass);
+};
+}  // namespace art
+#endif  // ART_COMPILER_DEX_PASS_H_