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