/*
* 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_ME_H_
#define ART_COMPILER_DEX_PASS_ME_H_
#include <string>
#include "base/logging.h"
#include "pass.h"
#include "compiler_ir.h"
#include "safe_map.h"
namespace art {
// Forward declarations.
class BasicBlock;
struct CompilationUnit;
/**
* @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 {
kOptimizationBasicBlockChange = 1, /// @brief Has there been a change to a BasicBlock?
kOptimizationDefUsesChange = 2, /// @brief Has there been a change to a def-use?
kLoopStructureChange = 4, /// @brief Has there been a loop structural change?
};
std::ostream& operator<<(std::ostream& os, const OptimizationFlag& rhs);
// Data holder class.
class PassMEDataHolder: public PassDataHolder {
public:
CompilationUnit* c_unit;
BasicBlock* bb;
void* data; /**< @brief Any data the pass wants to use */
bool dirty; /**< @brief Has the pass rendered the CFG dirty, requiring post-opt? */
};
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.
kTopologicalSortTraversal, /// @brief Topological Order traversal.
kLoopRepeatingTopologicalSortTraversal, /// @brief Loop-repeating Topological Order traversal.
kNoNodes, /// @brief Skip BasicBlock traversal.
};
std::ostream& operator<<(std::ostream& os, const DataFlowAnalysisMode& rhs);
/**
* @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 PassME : public Pass {
public:
explicit PassME(const char* name, DataFlowAnalysisMode type = kAllNodes,
unsigned int flags = 0u, const char* dump = "")
: Pass(name), traversal_type_(type), flags_(flags), dump_cfg_folder_(dump) {
}
PassME(const char* name, DataFlowAnalysisMode type, const char* dump)
: Pass(name), traversal_type_(type), flags_(0), dump_cfg_folder_(dump) {
}
PassME(const char* name, const char* dump)
: Pass(name), traversal_type_(kAllNodes), flags_(0), dump_cfg_folder_(dump) {
}
~PassME() {
default_options_.clear();
}
virtual DataFlowAnalysisMode GetTraversal() const {
return traversal_type_;
}
/**
* @return Returns whether the pass has any configurable options.
*/
bool HasOptions() const {
return default_options_.size() != 0;
}
/**
* @brief Prints the pass options along with default settings if there are any.
* @details The printing is done using LOG(INFO).
*/
void PrintPassDefaultOptions() const {
for (const auto& option : default_options_) {
LOG(INFO) << "\t" << option.first << ":" << option.second;
}
}
/**
* @brief Prints the pass options along with either default or overridden setting.
* @param overridden_options The overridden settings for this pass.
*/
void PrintPassOptions(SafeMap<const std::string, const OptionContent>& overridden_options) const {
// We walk through the default options only to get the pass names. We use GetPassOption to
// also consider the overridden ones.
for (const auto& option : default_options_) {
LOG(INFO) << "\t" << option.first << ":"
<< GetPassOption(option.first, overridden_options);
}
}
/**
* @brief Used to obtain the option structure for a pass.
* @details Will return the overridden option if it exists or default one otherwise.
* @param option_name The name of option whose setting to look for.
* @param c_unit The compilation unit currently being handled.
* @return Returns the option structure containing the option value.
*/
const OptionContent& GetPassOption(const char* option_name, CompilationUnit* c_unit) const {
return GetPassOption(option_name, c_unit->overridden_pass_options);
}
/**
* @brief Used to obtain the option for a pass as a string.
* @details Will return the overridden option if it exists or default one otherwise.
* It will return nullptr if the required option value is not a string.
* @param option_name The name of option whose setting to look for.
* @param c_unit The compilation unit currently being handled.
* @return Returns the overridden option if it exists or the default one otherwise.
*/
const char* GetStringPassOption(const char* option_name, CompilationUnit* c_unit) const {
return GetStringPassOption(option_name, c_unit->overridden_pass_options);
}
/**
* @brief Used to obtain the pass option value as an integer.
* @details Will return the overridden option if it exists or default one otherwise.
* It will return 0 if the required option value is not an integer.
* @param c_unit The compilation unit currently being handled.
* @return Returns the overriden option if it exists or the default one otherwise.
*/
int64_t GetIntegerPassOption(const char* option_name, CompilationUnit* c_unit) const {
return GetIntegerPassOption(option_name, c_unit->overridden_pass_options);
}
const char* GetDumpCFGFolder() const {
return dump_cfg_folder_;
}
bool GetFlag(OptimizationFlag flag) const {
return (flags_ & flag);
}
protected:
const OptionContent& GetPassOption(const char* option_name,
const SafeMap<const std::string, const OptionContent>& overridden_options) const {
DCHECK(option_name != nullptr);
// First check if there are any overridden settings.
auto overridden_it = overridden_options.find(std::string(option_name));
if (overridden_it != overridden_options.end()) {
return overridden_it->second;
} else {
// Otherwise, there must be a default value for this option name.
auto default_it = default_options_.find(option_name);
// An invalid option is being requested.
if (default_it == default_options_.end()) {
LOG(FATAL) << "Fatal: Cannot find an option named \"" << option_name << "\"";
}
return default_it->second;
}
}
const char* GetStringPassOption(const char* option_name,
const SafeMap<const std::string, const OptionContent>& overridden_options) const {
const OptionContent& option_content = GetPassOption(option_name, overridden_options);
if (option_content.type != OptionContent::kString) {
return nullptr;
}
return option_content.GetString();
}
int64_t GetIntegerPassOption(const char* option_name,
const SafeMap<const std::string, const OptionContent>& overridden_options) const {
const OptionContent& option_content = GetPassOption(option_name, overridden_options);
if (option_content.type != OptionContent::kInteger) {
return 0;
}
return option_content.GetInteger();
}
/** @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
* post-optimization pass is necessary. */
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_;
/**
* @brief Contains a map of options with the default settings.
* @details The constructor of the specific pass instance should fill this
* with default options.
* */
SafeMap<const char*, const OptionContent> default_options_;
};
} // namespace art
#endif // ART_COMPILER_DEX_PASS_ME_H_