Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 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 | |
Mathieu Chartier | b666f48 | 2015-02-18 14:33:14 -0800 | [diff] [blame] | 20 | #include "base/arena_object.h" |
Nicolas Geoffray | 3ff386a | 2014-03-04 14:46:47 +0000 | [diff] [blame] | 21 | #include "dex_file.h" |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 22 | #include "dex_file-inl.h" |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 23 | #include "driver/compiler_driver.h" |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 24 | #include "driver/dex_compilation_unit.h" |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 25 | #include "optimizing_compiler_stats.h" |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 26 | #include "primitive.h" |
Nicolas Geoffray | be9a92a | 2014-02-25 14:22:56 +0000 | [diff] [blame] | 27 | #include "utils/growable_array.h" |
Dave Allison | 20dfc79 | 2014-06-16 20:44:29 -0700 | [diff] [blame] | 28 | #include "nodes.h" |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 29 | |
| 30 | namespace art { |
| 31 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 32 | class Instruction; |
Andreas Gampe | e4d4d32 | 2014-12-04 09:09:57 -0800 | [diff] [blame] | 33 | class SwitchTable; |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 34 | |
| 35 | class HGraphBuilder : public ValueObject { |
| 36 | public: |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 37 | HGraphBuilder(HGraph* graph, |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 38 | DexCompilationUnit* dex_compilation_unit, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 39 | const DexCompilationUnit* const outer_compilation_unit, |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 40 | const DexFile* dex_file, |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 41 | CompilerDriver* driver, |
| 42 | OptimizingCompilerStats* compiler_stats) |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 43 | : arena_(graph->GetArena()), |
| 44 | branch_targets_(graph->GetArena(), 0), |
| 45 | locals_(graph->GetArena(), 0), |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 46 | entry_block_(nullptr), |
| 47 | exit_block_(nullptr), |
| 48 | current_block_(nullptr), |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 49 | graph_(graph), |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 50 | dex_file_(dex_file), |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 51 | dex_compilation_unit_(dex_compilation_unit), |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 52 | compiler_driver_(driver), |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 53 | outer_compilation_unit_(outer_compilation_unit), |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 54 | return_type_(Primitive::GetType(dex_compilation_unit_->GetShorty()[0])), |
| 55 | code_start_(nullptr), |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 56 | latest_result_(nullptr), |
| 57 | compilation_stats_(compiler_stats) {} |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 58 | |
| 59 | // Only for unit testing. |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 60 | HGraphBuilder(HGraph* graph, Primitive::Type return_type = Primitive::kPrimInt) |
| 61 | : arena_(graph->GetArena()), |
| 62 | branch_targets_(graph->GetArena(), 0), |
| 63 | locals_(graph->GetArena(), 0), |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 64 | entry_block_(nullptr), |
| 65 | exit_block_(nullptr), |
| 66 | current_block_(nullptr), |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 67 | graph_(graph), |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 68 | dex_file_(nullptr), |
| 69 | dex_compilation_unit_(nullptr), |
| 70 | compiler_driver_(nullptr), |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 71 | outer_compilation_unit_(nullptr), |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 72 | return_type_(return_type), |
| 73 | code_start_(nullptr), |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 74 | latest_result_(nullptr), |
| 75 | compilation_stats_(nullptr) {} |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 76 | |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 77 | bool BuildGraph(const DexFile::CodeItem& code); |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 78 | |
Andreas Gampe | 7c3952f | 2015-02-19 18:21:24 -0800 | [diff] [blame] | 79 | static constexpr const char* kBuilderPassName = "builder"; |
| 80 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 81 | private: |
| 82 | // Analyzes the dex instruction and adds HInstruction to the graph |
| 83 | // to execute that instruction. Returns whether the instruction can |
| 84 | // be handled. |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 85 | bool AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_pc); |
Nicolas Geoffray | be9a92a | 2014-02-25 14:22:56 +0000 | [diff] [blame] | 86 | |
| 87 | // Finds all instructions that start a new block, and populates branch_targets_ with |
| 88 | // the newly created blocks. |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 89 | // As a side effect, also compute the number of dex instructions, blocks, and |
| 90 | // branches. |
Calin Juravle | 702d260 | 2015-04-30 19:28:21 +0100 | [diff] [blame] | 91 | // Returns true if all the branches fall inside the method code, false otherwise. |
| 92 | // (In normal cases this should always return true but someone can artificially |
| 93 | // create a code unit in which branches fall-through out of it). |
| 94 | bool ComputeBranchTargets(const uint16_t* start, |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 95 | const uint16_t* end, |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 96 | size_t* number_of_branches); |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 97 | void MaybeUpdateCurrentBlock(size_t dex_pc); |
| 98 | HBasicBlock* FindBlockStartingAt(int32_t dex_pc) const; |
| 99 | HBasicBlock* FindOrCreateBlockStartingAt(int32_t dex_pc); |
David Brazdil | 56e1acc | 2015-06-30 15:41:36 +0100 | [diff] [blame] | 100 | |
David Brazdil | 49bace1 | 2015-07-01 15:28:26 +0100 | [diff] [blame] | 101 | // Adds new blocks to `branch_targets_` starting at the limits of TryItems and |
| 102 | // their exception handlers. |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 103 | void CreateBlocksForTryCatch(const DexFile::CodeItem& code_item); |
David Brazdil | 49bace1 | 2015-07-01 15:28:26 +0100 | [diff] [blame] | 104 | |
| 105 | // Splits edges which cross the boundaries of TryItems, inserts TryBoundary |
| 106 | // instructions and links them to the corresponding catch blocks. |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 107 | void InsertTryBoundaryBlocks(const DexFile::CodeItem& code_item); |
David Brazdil | 49bace1 | 2015-07-01 15:28:26 +0100 | [diff] [blame] | 108 | |
| 109 | // Splits a single edge, inserting a TryBoundary of given `kind` and linking |
| 110 | // it to exception handlers of `try_item`. |
David Brazdil | 56e1acc | 2015-06-30 15:41:36 +0100 | [diff] [blame] | 111 | void SplitTryBoundaryEdge(HBasicBlock* predecessor, |
| 112 | HBasicBlock* successor, |
| 113 | HTryBoundary::BoundaryKind kind, |
| 114 | const DexFile::CodeItem& code_item, |
| 115 | const DexFile::TryItem& try_item); |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 116 | |
Nicolas Geoffray | f583e59 | 2014-04-07 13:20:42 +0100 | [diff] [blame] | 117 | void InitializeLocals(uint16_t count); |
Nicolas Geoffray | 3ff386a | 2014-03-04 14:46:47 +0000 | [diff] [blame] | 118 | HLocal* GetLocalAt(int register_index) const; |
| 119 | void UpdateLocal(int register_index, HInstruction* instruction) const; |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 120 | HInstruction* LoadLocal(int register_index, Primitive::Type type) const; |
David Brazdil | 852eaff | 2015-02-02 15:23:05 +0000 | [diff] [blame] | 121 | void PotentiallyAddSuspendCheck(HBasicBlock* target, uint32_t dex_pc); |
Nicolas Geoffray | 52e832b | 2014-11-06 15:15:31 +0000 | [diff] [blame] | 122 | void InitializeParameters(uint16_t number_of_parameters); |
Nicolas Geoffray | cb1b00a | 2015-01-28 14:50:01 +0000 | [diff] [blame] | 123 | bool NeedsAccessCheck(uint32_t type_index) const; |
Nicolas Geoffray | f583e59 | 2014-04-07 13:20:42 +0100 | [diff] [blame] | 124 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 125 | template<typename T> |
Roland Levillain | 88cb175 | 2014-10-20 16:36:47 +0100 | [diff] [blame] | 126 | void Unop_12x(const Instruction& instruction, Primitive::Type type); |
| 127 | |
| 128 | template<typename T> |
Nicolas Geoffray | 412f10c | 2014-06-19 10:00:34 +0100 | [diff] [blame] | 129 | void Binop_23x(const Instruction& instruction, Primitive::Type type); |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 130 | |
| 131 | template<typename T> |
Calin Juravle | d6fb6cf | 2014-11-11 19:07:44 +0000 | [diff] [blame] | 132 | void Binop_23x(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
| 133 | |
| 134 | template<typename T> |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 135 | void Binop_23x_shift(const Instruction& instruction, Primitive::Type type); |
| 136 | |
Alexey Frunze | 4dda337 | 2015-06-01 18:31:49 -0700 | [diff] [blame] | 137 | void Binop_23x_cmp(const Instruction& instruction, |
| 138 | Primitive::Type type, |
Mark Mendell | c470193 | 2015-04-10 13:18:51 -0400 | [diff] [blame] | 139 | ComparisonBias bias, |
Alexey Frunze | 4dda337 | 2015-06-01 18:31:49 -0700 | [diff] [blame] | 140 | uint32_t dex_pc); |
Calin Juravle | ddb7df2 | 2014-11-25 20:56:51 +0000 | [diff] [blame] | 141 | |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 142 | template<typename T> |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 143 | void Binop_12x(const Instruction& instruction, Primitive::Type type); |
| 144 | |
| 145 | template<typename T> |
Calin Juravle | d6fb6cf | 2014-11-11 19:07:44 +0000 | [diff] [blame] | 146 | void Binop_12x(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
| 147 | |
| 148 | template<typename T> |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 149 | void Binop_12x_shift(const Instruction& instruction, Primitive::Type type); |
| 150 | |
| 151 | template<typename T> |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 152 | void Binop_22b(const Instruction& instruction, bool reverse); |
| 153 | |
| 154 | template<typename T> |
| 155 | void Binop_22s(const Instruction& instruction, bool reverse); |
| 156 | |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 157 | template<typename T> void If_21t(const Instruction& instruction, uint32_t dex_pc); |
| 158 | template<typename T> void If_22t(const Instruction& instruction, uint32_t dex_pc); |
Nicolas Geoffray | f583e59 | 2014-04-07 13:20:42 +0100 | [diff] [blame] | 159 | |
Roland Levillain | dff1f28 | 2014-11-05 14:15:05 +0000 | [diff] [blame] | 160 | void Conversion_12x(const Instruction& instruction, |
| 161 | Primitive::Type input_type, |
Roland Levillain | 624279f | 2014-12-04 11:54:28 +0000 | [diff] [blame] | 162 | Primitive::Type result_type, |
| 163 | uint32_t dex_pc); |
Roland Levillain | dff1f28 | 2014-11-05 14:15:05 +0000 | [diff] [blame] | 164 | |
Calin Juravle | bacfec3 | 2014-11-14 15:54:36 +0000 | [diff] [blame] | 165 | void BuildCheckedDivRem(uint16_t out_reg, |
| 166 | uint16_t first_reg, |
| 167 | int64_t second_reg_or_constant, |
| 168 | uint32_t dex_pc, |
| 169 | Primitive::Type type, |
| 170 | bool second_is_lit, |
| 171 | bool is_div); |
Calin Juravle | d0d4852 | 2014-11-04 16:40:20 +0000 | [diff] [blame] | 172 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 173 | void BuildReturn(const Instruction& instruction, Primitive::Type type); |
| 174 | |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 175 | // Builds an instance field access node and returns whether the instruction is supported. |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 176 | bool BuildInstanceFieldAccess(const Instruction& instruction, uint32_t dex_pc, bool is_put); |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 177 | |
| 178 | // Builds a static field access node and returns whether the instruction is supported. |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 179 | bool BuildStaticFieldAccess(const Instruction& instruction, uint32_t dex_pc, bool is_put); |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 180 | |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 181 | void BuildArrayAccess(const Instruction& instruction, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 182 | uint32_t dex_pc, |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 183 | bool is_get, |
| 184 | Primitive::Type anticipated_type); |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 185 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 186 | // Builds an invocation node and returns whether the instruction is supported. |
| 187 | bool BuildInvoke(const Instruction& instruction, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 188 | uint32_t dex_pc, |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 189 | uint32_t method_idx, |
| 190 | uint32_t number_of_vreg_arguments, |
| 191 | bool is_range, |
| 192 | uint32_t* args, |
| 193 | uint32_t register_index); |
| 194 | |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 195 | // Builds a new array node and the instructions that fill it. |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 196 | void BuildFilledNewArray(uint32_t dex_pc, |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 197 | uint32_t type_index, |
| 198 | uint32_t number_of_vreg_arguments, |
| 199 | bool is_range, |
| 200 | uint32_t* args, |
| 201 | uint32_t register_index); |
| 202 | |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 203 | void BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc); |
Calin Juravle | d0d4852 | 2014-11-04 16:40:20 +0000 | [diff] [blame] | 204 | |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 205 | // Fills the given object with data as specified in the fill-array-data |
| 206 | // instruction. Currently only used for non-reference and non-floating point |
| 207 | // arrays. |
| 208 | template <typename T> |
| 209 | void BuildFillArrayData(HInstruction* object, |
| 210 | const T* data, |
| 211 | uint32_t element_count, |
| 212 | Primitive::Type anticipated_type, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 213 | uint32_t dex_pc); |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 214 | |
| 215 | // Fills the given object with data as specified in the fill-array-data |
| 216 | // instruction. The data must be for long and double arrays. |
| 217 | void BuildFillWideArrayData(HInstruction* object, |
Nicolas Geoffray | 8d6ae52 | 2014-10-23 18:32:13 +0100 | [diff] [blame] | 218 | const int64_t* data, |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 219 | uint32_t element_count, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 220 | uint32_t dex_pc); |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 221 | |
Nicolas Geoffray | 57a88d4 | 2014-11-10 15:09:21 +0000 | [diff] [blame] | 222 | // Builds a `HInstanceOf`, or a `HCheckCast` instruction. |
| 223 | // Returns whether we succeeded in building the instruction. |
| 224 | bool BuildTypeCheck(const Instruction& instruction, |
| 225 | uint8_t destination, |
| 226 | uint8_t reference, |
| 227 | uint16_t type_index, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 228 | uint32_t dex_pc); |
Nicolas Geoffray | 57a88d4 | 2014-11-10 15:09:21 +0000 | [diff] [blame] | 229 | |
Andreas Gampe | e4d4d32 | 2014-12-04 09:09:57 -0800 | [diff] [blame] | 230 | // Builds an instruction sequence for a packed switch statement. |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 231 | void BuildPackedSwitch(const Instruction& instruction, uint32_t dex_pc); |
Andreas Gampe | d881df5 | 2014-11-24 23:28:39 -0800 | [diff] [blame] | 232 | |
Andreas Gampe | e4d4d32 | 2014-12-04 09:09:57 -0800 | [diff] [blame] | 233 | // Builds an instruction sequence for a sparse switch statement. |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 234 | void BuildSparseSwitch(const Instruction& instruction, uint32_t dex_pc); |
Andreas Gampe | e4d4d32 | 2014-12-04 09:09:57 -0800 | [diff] [blame] | 235 | |
| 236 | void BuildSwitchCaseHelper(const Instruction& instruction, size_t index, |
| 237 | bool is_last_case, const SwitchTable& table, |
| 238 | HInstruction* value, int32_t case_value_int, |
| 239 | int32_t target_offset, uint32_t dex_pc); |
| 240 | |
David Brazdil | 1b49872 | 2015-03-31 11:37:18 +0100 | [diff] [blame] | 241 | bool SkipCompilation(const DexFile::CodeItem& code_item, size_t number_of_branches); |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 242 | |
| 243 | void MaybeRecordStat(MethodCompilationStat compilation_stat); |
| 244 | |
Nicolas Geoffray | 3045174 | 2015-06-19 13:32:41 +0100 | [diff] [blame] | 245 | // Returns the outer-most compiling method's class. |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 246 | mirror::Class* GetOutermostCompilingClass() const; |
| 247 | |
Nicolas Geoffray | 3045174 | 2015-06-19 13:32:41 +0100 | [diff] [blame] | 248 | // Returns the class whose method is being compiled. |
| 249 | mirror::Class* GetCompilingClass() const; |
| 250 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 251 | // Returns whether `type_index` points to the outer-most compiling method's class. |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 252 | bool IsOutermostCompilingClass(uint16_t type_index) const; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 253 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 254 | ArenaAllocator* const arena_; |
Nicolas Geoffray | be9a92a | 2014-02-25 14:22:56 +0000 | [diff] [blame] | 255 | |
| 256 | // A list of the size of the dex code holding block information for |
| 257 | // the method. If an entry contains a block, then the dex instruction |
| 258 | // starting at that entry is the first instruction of a new block. |
| 259 | GrowableArray<HBasicBlock*> branch_targets_; |
| 260 | |
Nicolas Geoffray | 3ff386a | 2014-03-04 14:46:47 +0000 | [diff] [blame] | 261 | GrowableArray<HLocal*> locals_; |
| 262 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 263 | HBasicBlock* entry_block_; |
| 264 | HBasicBlock* exit_block_; |
| 265 | HBasicBlock* current_block_; |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 266 | HGraph* const graph_; |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 267 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 268 | // The dex file where the method being compiled is. |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 269 | const DexFile* const dex_file_; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 270 | |
| 271 | // The compilation unit of the current method being compiled. Note that |
| 272 | // it can be an inlined method. |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 273 | DexCompilationUnit* const dex_compilation_unit_; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 274 | |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 275 | CompilerDriver* const compiler_driver_; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 276 | |
| 277 | // The compilation unit of the outermost method being compiled. That is the |
| 278 | // method being compiled (and not inlined), and potentially inlining other |
| 279 | // methods. |
| 280 | const DexCompilationUnit* const outer_compilation_unit_; |
| 281 | |
| 282 | // The return type of the method being compiled. |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 283 | const Primitive::Type return_type_; |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 284 | |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 285 | // The pointer in the dex file where the instructions of the code item |
| 286 | // being currently compiled start. |
| 287 | const uint16_t* code_start_; |
| 288 | |
| 289 | // The last invoke or fill-new-array being built. Only to be |
| 290 | // used by move-result instructions. |
| 291 | HInstruction* latest_result_; |
| 292 | |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 293 | OptimizingCompilerStats* compilation_stats_; |
| 294 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 295 | DISALLOW_COPY_AND_ASSIGN(HGraphBuilder); |
| 296 | }; |
| 297 | |
| 298 | } // namespace art |
| 299 | |
| 300 | #endif // ART_COMPILER_OPTIMIZING_BUILDER_H_ |