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_BUILDER_H_
     18 #define ART_COMPILER_OPTIMIZING_BUILDER_H_
     19 
     20 #include "dex_file.h"
     21 #include "driver/compiler_driver.h"
     22 #include "driver/dex_compilation_unit.h"
     23 #include "primitive.h"
     24 #include "utils/allocation.h"
     25 #include "utils/growable_array.h"
     26 #include "nodes.h"
     27 
     28 namespace art {
     29 
     30 class Instruction;
     31 
     32 class HGraphBuilder : public ValueObject {
     33  public:
     34   HGraphBuilder(ArenaAllocator* arena,
     35                 DexCompilationUnit* dex_compilation_unit = nullptr,
     36                 const DexFile* dex_file = nullptr,
     37                 CompilerDriver* driver = nullptr)
     38       : arena_(arena),
     39         branch_targets_(arena, 0),
     40         locals_(arena, 0),
     41         entry_block_(nullptr),
     42         exit_block_(nullptr),
     43         current_block_(nullptr),
     44         graph_(nullptr),
     45         constant0_(nullptr),
     46         constant1_(nullptr),
     47         dex_file_(dex_file),
     48         dex_compilation_unit_(dex_compilation_unit),
     49         compiler_driver_(driver) {}
     50 
     51   HGraph* BuildGraph(const DexFile::CodeItem& code);
     52 
     53  private:
     54   // Analyzes the dex instruction and adds HInstruction to the graph
     55   // to execute that instruction. Returns whether the instruction can
     56   // be handled.
     57   bool AnalyzeDexInstruction(const Instruction& instruction, int32_t dex_offset);
     58 
     59   // Finds all instructions that start a new block, and populates branch_targets_ with
     60   // the newly created blocks.
     61   void ComputeBranchTargets(const uint16_t* start, const uint16_t* end);
     62   void MaybeUpdateCurrentBlock(size_t index);
     63   HBasicBlock* FindBlockStartingAt(int32_t index) const;
     64 
     65   HIntConstant* GetIntConstant0();
     66   HIntConstant* GetIntConstant1();
     67   HIntConstant* GetIntConstant(int32_t constant);
     68   HLongConstant* GetLongConstant(int64_t constant);
     69   void InitializeLocals(uint16_t count);
     70   HLocal* GetLocalAt(int register_index) const;
     71   void UpdateLocal(int register_index, HInstruction* instruction) const;
     72   HInstruction* LoadLocal(int register_index, Primitive::Type type) const;
     73 
     74   // Temporarily returns whether the compiler supports the parameters
     75   // of the method.
     76   bool InitializeParameters(uint16_t number_of_parameters);
     77 
     78   template<typename T>
     79   void Binop_23x(const Instruction& instruction, Primitive::Type type);
     80 
     81   template<typename T>
     82   void Binop_12x(const Instruction& instruction, Primitive::Type type);
     83 
     84   template<typename T>
     85   void Binop_22b(const Instruction& instruction, bool reverse);
     86 
     87   template<typename T>
     88   void Binop_22s(const Instruction& instruction, bool reverse);
     89 
     90   template<typename T> void If_21t(const Instruction& instruction, uint32_t dex_offset);
     91   template<typename T> void If_22t(const Instruction& instruction, uint32_t dex_offset);
     92 
     93   void BuildReturn(const Instruction& instruction, Primitive::Type type);
     94 
     95   bool BuildFieldAccess(const Instruction& instruction, uint32_t dex_offset, bool is_get);
     96   void BuildArrayAccess(const Instruction& instruction,
     97                         uint32_t dex_offset,
     98                         bool is_get,
     99                         Primitive::Type anticipated_type);
    100 
    101   // Builds an invocation node and returns whether the instruction is supported.
    102   bool BuildInvoke(const Instruction& instruction,
    103                    uint32_t dex_offset,
    104                    uint32_t method_idx,
    105                    uint32_t number_of_vreg_arguments,
    106                    bool is_range,
    107                    uint32_t* args,
    108                    uint32_t register_index);
    109 
    110   ArenaAllocator* const arena_;
    111 
    112   // A list of the size of the dex code holding block information for
    113   // the method. If an entry contains a block, then the dex instruction
    114   // starting at that entry is the first instruction of a new block.
    115   GrowableArray<HBasicBlock*> branch_targets_;
    116 
    117   GrowableArray<HLocal*> locals_;
    118 
    119   HBasicBlock* entry_block_;
    120   HBasicBlock* exit_block_;
    121   HBasicBlock* current_block_;
    122   HGraph* graph_;
    123 
    124   HIntConstant* constant0_;
    125   HIntConstant* constant1_;
    126 
    127   const DexFile* const dex_file_;
    128   DexCompilationUnit* const dex_compilation_unit_;
    129   CompilerDriver* const compiler_driver_;
    130 
    131   DISALLOW_COPY_AND_ASSIGN(HGraphBuilder);
    132 };
    133 
    134 }  // namespace art
    135 
    136 #endif  // ART_COMPILER_OPTIMIZING_BUILDER_H_
    137