Home | History | Annotate | Download | only in optimizing 
      1 /*
      2  * Copyright (C) 2014 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef ART_COMPILER_OPTIMIZING_OPTIMIZATION_H_
     18 #define ART_COMPILER_OPTIMIZING_OPTIMIZATION_H_
     19 
     20 #include "base/arena_object.h"
     21 #include "nodes.h"
     22 #include "optimizing_compiler_stats.h"
     23 
     24 namespace art {
     25 
     26 class CodeGenerator;
     27 class CompilerDriver;
     28 class DexCompilationUnit;
     29 
     30 /**
     31  * Abstraction to implement an optimization pass.
     32  */
     33 class HOptimization : public ArenaObject<kArenaAllocOptimization> {
     34  public:
     35   HOptimization(HGraph* graph,
     36                 const char* pass_name,
     37                 OptimizingCompilerStats* stats = nullptr)
     38       : graph_(graph),
     39         stats_(stats),
     40         pass_name_(pass_name) {}
     41 
     42   virtual ~HOptimization() {}
     43 
     44   // Return the name of the pass. Pass names for a single HOptimization should be of form
     45   // <optimization_name> or <optimization_name>$<pass_name> for common <optimization_name> prefix.
     46   // Example: 'instruction_simplifier', 'instruction_simplifier$after_bce',
     47   // 'instruction_simplifier$before_codegen'.
     48   const char* GetPassName() const { return pass_name_; }
     49 
     50   // Perform the analysis itself.
     51   virtual void Run() = 0;
     52 
     53  protected:
     54   HGraph* const graph_;
     55   // Used to record stats about the optimization.
     56   OptimizingCompilerStats* const stats_;
     57 
     58  private:
     59   // Optimization pass name.
     60   const char* pass_name_;
     61 
     62   DISALLOW_COPY_AND_ASSIGN(HOptimization);
     63 };
     64 
     65 // Optimization passes that can be constructed by the helper method below. An enum
     66 // field is preferred over a string lookup at places where performance matters.
     67 // TODO: generate this table and lookup methods below automatically?
     68 enum class OptimizationPass {
     69   kBoundsCheckElimination,
     70   kCHAGuardOptimization,
     71   kCodeSinking,
     72   kConstantFolding,
     73   kConstructorFenceRedundancyElimination,
     74   kDeadCodeElimination,
     75   kGlobalValueNumbering,
     76   kInductionVarAnalysis,
     77   kInliner,
     78   kInstructionSimplifier,
     79   kIntrinsicsRecognizer,
     80   kInvariantCodeMotion,
     81   kLoadStoreAnalysis,
     82   kLoadStoreElimination,
     83   kLoopOptimization,
     84   kScheduling,
     85   kSelectGenerator,
     86   kSharpening,
     87   kSideEffectsAnalysis,
     88 #ifdef ART_ENABLE_CODEGEN_arm
     89   kInstructionSimplifierArm,
     90 #endif
     91 #ifdef ART_ENABLE_CODEGEN_arm64
     92   kInstructionSimplifierArm64,
     93 #endif
     94 #ifdef ART_ENABLE_CODEGEN_mips
     95   kPcRelativeFixupsMips,
     96   kInstructionSimplifierMips,
     97 #endif
     98 #ifdef ART_ENABLE_CODEGEN_x86
     99   kPcRelativeFixupsX86,
    100 #endif
    101 #if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
    102   kX86MemoryOperandGeneration,
    103 #endif
    104 };
    105 
    106 // Lookup name of optimization pass.
    107 const char* OptimizationPassName(OptimizationPass pass);
    108 
    109 // Lookup optimization pass by name.
    110 OptimizationPass OptimizationPassByName(const std::string& name);
    111 
    112 // Optimization definition consisting of an optimization pass
    113 // and an optional alternative name (nullptr denotes default).
    114 typedef std::pair<OptimizationPass, const char*> OptimizationDef;
    115 
    116 // Helper method for optimization definition array entries.
    117 inline OptimizationDef OptDef(OptimizationPass pass, const char* name = nullptr) {
    118   return std::make_pair(pass, name);
    119 }
    120 
    121 // Helper method to construct series of optimization passes.
    122 // The array should consist of the requested optimizations
    123 // and optional alternative names for repeated passes.
    124 // Example:
    125 //    { OptPass(kConstantFolding),
    126 //      OptPass(Inliner),
    127 //      OptPass(kConstantFolding, "constant_folding$after_inlining")
    128 //    }
    129 ArenaVector<HOptimization*> ConstructOptimizations(
    130     const OptimizationDef definitions[],
    131     size_t length,
    132     ArenaAllocator* allocator,
    133     HGraph* graph,
    134     OptimizingCompilerStats* stats,
    135     CodeGenerator* codegen,
    136     CompilerDriver* driver,
    137     const DexCompilationUnit& dex_compilation_unit,
    138     VariableSizedHandleScope* handles);
    139 
    140 }  // namespace art
    141 
    142 #endif  // ART_COMPILER_OPTIMIZING_OPTIMIZATION_H_
    143