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>
diff --git a/compiler/dex/pass.h b/compiler/dex/pass.h
new file mode 100644
index 0000000..c52ddf5
--- /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_