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 | |
Vladimir Marko | 2aaa4b5 | 2015-09-17 17:03:26 +0100 | [diff] [blame] | 20 | #include "base/arena_containers.h" |
Mathieu Chartier | b666f48 | 2015-02-18 14:33:14 -0800 | [diff] [blame] | 21 | #include "base/arena_object.h" |
Nicolas Geoffray | 3ff386a | 2014-03-04 14:46:47 +0000 | [diff] [blame] | 22 | #include "dex_file.h" |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 23 | #include "dex_file-inl.h" |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 24 | #include "driver/compiler_driver.h" |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 25 | #include "driver/dex_compilation_unit.h" |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 26 | #include "optimizing_compiler_stats.h" |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 27 | #include "primitive.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, |
Nicolas Geoffray | 9523a3e | 2015-07-17 11:51:28 +0000 | [diff] [blame] | 42 | OptimizingCompilerStats* compiler_stats, |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 43 | const uint8_t* interpreter_metadata, |
| 44 | Handle<mirror::DexCache> dex_cache) |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 45 | : arena_(graph->GetArena()), |
Vladimir Marko | 2aaa4b5 | 2015-09-17 17:03:26 +0100 | [diff] [blame] | 46 | branch_targets_(graph->GetArena()->Adapter(kArenaAllocGraphBuilder)), |
| 47 | locals_(graph->GetArena()->Adapter(kArenaAllocGraphBuilder)), |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 48 | entry_block_(nullptr), |
| 49 | exit_block_(nullptr), |
| 50 | current_block_(nullptr), |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 51 | graph_(graph), |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 52 | dex_file_(dex_file), |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 53 | dex_compilation_unit_(dex_compilation_unit), |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 54 | compiler_driver_(driver), |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 55 | outer_compilation_unit_(outer_compilation_unit), |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 56 | return_type_(Primitive::GetType(dex_compilation_unit_->GetShorty()[0])), |
| 57 | code_start_(nullptr), |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 58 | latest_result_(nullptr), |
Nicolas Geoffray | 2e7cd75 | 2015-07-10 11:38:52 +0100 | [diff] [blame] | 59 | can_use_baseline_for_string_init_(true), |
Nicolas Geoffray | 9523a3e | 2015-07-17 11:51:28 +0000 | [diff] [blame] | 60 | compilation_stats_(compiler_stats), |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 61 | interpreter_metadata_(interpreter_metadata), |
| 62 | dex_cache_(dex_cache) {} |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 63 | |
| 64 | // Only for unit testing. |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 65 | HGraphBuilder(HGraph* graph, Primitive::Type return_type = Primitive::kPrimInt) |
| 66 | : arena_(graph->GetArena()), |
Vladimir Marko | 2aaa4b5 | 2015-09-17 17:03:26 +0100 | [diff] [blame] | 67 | branch_targets_(graph->GetArena()->Adapter(kArenaAllocGraphBuilder)), |
| 68 | locals_(graph->GetArena()->Adapter(kArenaAllocGraphBuilder)), |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 69 | entry_block_(nullptr), |
| 70 | exit_block_(nullptr), |
| 71 | current_block_(nullptr), |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 72 | graph_(graph), |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 73 | dex_file_(nullptr), |
| 74 | dex_compilation_unit_(nullptr), |
| 75 | compiler_driver_(nullptr), |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 76 | outer_compilation_unit_(nullptr), |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 77 | return_type_(return_type), |
| 78 | code_start_(nullptr), |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 79 | latest_result_(nullptr), |
Nicolas Geoffray | 2e7cd75 | 2015-07-10 11:38:52 +0100 | [diff] [blame] | 80 | can_use_baseline_for_string_init_(true), |
Sebastien Hertz | aa50d3a | 2015-08-25 15:25:41 +0200 | [diff] [blame] | 81 | compilation_stats_(nullptr), |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 82 | interpreter_metadata_(nullptr), |
| 83 | dex_cache_(NullHandle<mirror::DexCache>()) {} |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 84 | |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 85 | bool BuildGraph(const DexFile::CodeItem& code); |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 86 | |
Nicolas Geoffray | 2e7cd75 | 2015-07-10 11:38:52 +0100 | [diff] [blame] | 87 | bool CanUseBaselineForStringInit() const { |
| 88 | return can_use_baseline_for_string_init_; |
| 89 | } |
| 90 | |
Andreas Gampe | 7c3952f | 2015-02-19 18:21:24 -0800 | [diff] [blame] | 91 | static constexpr const char* kBuilderPassName = "builder"; |
| 92 | |
Mark Mendell | fe57faa | 2015-09-18 09:26:15 -0400 | [diff] [blame] | 93 | // The number of entries in a packed switch before we use a jump table. |
| 94 | static constexpr uint16_t kSmallSwitchThreshold = 5; |
| 95 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 96 | private: |
| 97 | // Analyzes the dex instruction and adds HInstruction to the graph |
| 98 | // to execute that instruction. Returns whether the instruction can |
| 99 | // be handled. |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 100 | bool AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_pc); |
Nicolas Geoffray | be9a92a | 2014-02-25 14:22:56 +0000 | [diff] [blame] | 101 | |
| 102 | // Finds all instructions that start a new block, and populates branch_targets_ with |
| 103 | // the newly created blocks. |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 104 | // As a side effect, also compute the number of dex instructions, blocks, and |
| 105 | // branches. |
Calin Juravle | 702d260 | 2015-04-30 19:28:21 +0100 | [diff] [blame] | 106 | // Returns true if all the branches fall inside the method code, false otherwise. |
| 107 | // (In normal cases this should always return true but someone can artificially |
| 108 | // create a code unit in which branches fall-through out of it). |
| 109 | bool ComputeBranchTargets(const uint16_t* start, |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 110 | const uint16_t* end, |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 111 | size_t* number_of_branches); |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 112 | void MaybeUpdateCurrentBlock(size_t dex_pc); |
| 113 | HBasicBlock* FindBlockStartingAt(int32_t dex_pc) const; |
| 114 | HBasicBlock* FindOrCreateBlockStartingAt(int32_t dex_pc); |
David Brazdil | 56e1acc | 2015-06-30 15:41:36 +0100 | [diff] [blame] | 115 | |
David Brazdil | 49bace1 | 2015-07-01 15:28:26 +0100 | [diff] [blame] | 116 | // Adds new blocks to `branch_targets_` starting at the limits of TryItems and |
| 117 | // their exception handlers. |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 118 | void CreateBlocksForTryCatch(const DexFile::CodeItem& code_item); |
David Brazdil | 49bace1 | 2015-07-01 15:28:26 +0100 | [diff] [blame] | 119 | |
| 120 | // Splits edges which cross the boundaries of TryItems, inserts TryBoundary |
| 121 | // instructions and links them to the corresponding catch blocks. |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 122 | void InsertTryBoundaryBlocks(const DexFile::CodeItem& code_item); |
David Brazdil | 49bace1 | 2015-07-01 15:28:26 +0100 | [diff] [blame] | 123 | |
David Brazdil | d7558da | 2015-09-22 13:04:14 +0100 | [diff] [blame] | 124 | // Iterates over the exception handlers of `try_item`, finds the corresponding |
| 125 | // catch blocks and makes them successors of `try_boundary`. The order of |
| 126 | // successors matches the order in which runtime exception delivery searches |
| 127 | // for a handler. |
| 128 | void LinkToCatchBlocks(HTryBoundary* try_boundary, |
| 129 | const DexFile::CodeItem& code_item, |
| 130 | const DexFile::TryItem* try_item); |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 131 | |
Nicolas Geoffray | 9523a3e | 2015-07-17 11:51:28 +0000 | [diff] [blame] | 132 | bool CanDecodeQuickenedInfo() const; |
| 133 | uint16_t LookupQuickenedInfo(uint32_t dex_pc); |
| 134 | |
Nicolas Geoffray | f583e59 | 2014-04-07 13:20:42 +0100 | [diff] [blame] | 135 | void InitializeLocals(uint16_t count); |
Vladimir Marko | 2aaa4b5 | 2015-09-17 17:03:26 +0100 | [diff] [blame] | 136 | HLocal* GetLocalAt(uint32_t register_index) const; |
| 137 | void UpdateLocal(uint32_t register_index, HInstruction* instruction, uint32_t dex_pc) const; |
| 138 | HInstruction* LoadLocal(uint32_t register_index, Primitive::Type type, uint32_t dex_pc) const; |
David Brazdil | 852eaff | 2015-02-02 15:23:05 +0000 | [diff] [blame] | 139 | void PotentiallyAddSuspendCheck(HBasicBlock* target, uint32_t dex_pc); |
Nicolas Geoffray | 52e832b | 2014-11-06 15:15:31 +0000 | [diff] [blame] | 140 | void InitializeParameters(uint16_t number_of_parameters); |
Mingyao Yang | fb8464a | 2015-11-02 10:56:59 -0800 | [diff] [blame] | 141 | |
| 142 | // Returns whether the current method needs access check for the type. |
| 143 | // Output parameter finalizable is set to whether the type is finalizable. |
| 144 | bool NeedsAccessCheck(uint32_t type_index, /*out*/bool* finalizable) const; |
Nicolas Geoffray | f583e59 | 2014-04-07 13:20:42 +0100 | [diff] [blame] | 145 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 146 | template<typename T> |
Yevgeny Rouban | 3ecfd65 | 2015-09-07 17:57:00 +0600 | [diff] [blame] | 147 | void Unop_12x(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 148 | |
| 149 | template<typename T> |
Calin Juravle | d6fb6cf | 2014-11-11 19:07:44 +0000 | [diff] [blame] | 150 | void Binop_23x(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
| 151 | |
| 152 | template<typename T> |
Yevgeny Rouban | 3ecfd65 | 2015-09-07 17:57:00 +0600 | [diff] [blame] | 153 | void Binop_23x_shift(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 154 | |
Alexey Frunze | 4dda337 | 2015-06-01 18:31:49 -0700 | [diff] [blame] | 155 | void Binop_23x_cmp(const Instruction& instruction, |
| 156 | Primitive::Type type, |
Mark Mendell | c470193 | 2015-04-10 13:18:51 -0400 | [diff] [blame] | 157 | ComparisonBias bias, |
Alexey Frunze | 4dda337 | 2015-06-01 18:31:49 -0700 | [diff] [blame] | 158 | uint32_t dex_pc); |
Calin Juravle | ddb7df2 | 2014-11-25 20:56:51 +0000 | [diff] [blame] | 159 | |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 160 | template<typename T> |
Calin Juravle | d6fb6cf | 2014-11-11 19:07:44 +0000 | [diff] [blame] | 161 | void Binop_12x(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
| 162 | |
| 163 | template<typename T> |
Yevgeny Rouban | 3ecfd65 | 2015-09-07 17:57:00 +0600 | [diff] [blame] | 164 | void Binop_12x_shift(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 165 | |
| 166 | template<typename T> |
Yevgeny Rouban | 3ecfd65 | 2015-09-07 17:57:00 +0600 | [diff] [blame] | 167 | void Binop_22b(const Instruction& instruction, bool reverse, uint32_t dex_pc); |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 168 | |
| 169 | template<typename T> |
Yevgeny Rouban | 3ecfd65 | 2015-09-07 17:57:00 +0600 | [diff] [blame] | 170 | void Binop_22s(const Instruction& instruction, bool reverse, uint32_t dex_pc); |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 171 | |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 172 | template<typename T> void If_21t(const Instruction& instruction, uint32_t dex_pc); |
| 173 | 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] | 174 | |
Roland Levillain | dff1f28 | 2014-11-05 14:15:05 +0000 | [diff] [blame] | 175 | void Conversion_12x(const Instruction& instruction, |
| 176 | Primitive::Type input_type, |
Roland Levillain | 624279f | 2014-12-04 11:54:28 +0000 | [diff] [blame] | 177 | Primitive::Type result_type, |
| 178 | uint32_t dex_pc); |
Roland Levillain | dff1f28 | 2014-11-05 14:15:05 +0000 | [diff] [blame] | 179 | |
Calin Juravle | bacfec3 | 2014-11-14 15:54:36 +0000 | [diff] [blame] | 180 | void BuildCheckedDivRem(uint16_t out_reg, |
| 181 | uint16_t first_reg, |
| 182 | int64_t second_reg_or_constant, |
| 183 | uint32_t dex_pc, |
| 184 | Primitive::Type type, |
| 185 | bool second_is_lit, |
| 186 | bool is_div); |
Calin Juravle | d0d4852 | 2014-11-04 16:40:20 +0000 | [diff] [blame] | 187 | |
Yevgeny Rouban | 3ecfd65 | 2015-09-07 17:57:00 +0600 | [diff] [blame] | 188 | void BuildReturn(const Instruction& instruction, Primitive::Type type, uint32_t dex_pc); |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 189 | |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 190 | // 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] | 191 | bool BuildInstanceFieldAccess(const Instruction& instruction, uint32_t dex_pc, bool is_put); |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 192 | |
Calin Juravle | 07380a2 | 2015-09-17 14:15:12 +0100 | [diff] [blame] | 193 | void BuildUnresolvedStaticFieldAccess(const Instruction& instruction, |
| 194 | uint32_t dex_pc, |
| 195 | bool is_put, |
| 196 | Primitive::Type field_type); |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 197 | // 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] | 198 | bool BuildStaticFieldAccess(const Instruction& instruction, uint32_t dex_pc, bool is_put); |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 199 | |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 200 | void BuildArrayAccess(const Instruction& instruction, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 201 | uint32_t dex_pc, |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 202 | bool is_get, |
| 203 | Primitive::Type anticipated_type); |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 204 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 205 | // Builds an invocation node and returns whether the instruction is supported. |
| 206 | bool BuildInvoke(const Instruction& instruction, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 207 | uint32_t dex_pc, |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 208 | uint32_t method_idx, |
| 209 | uint32_t number_of_vreg_arguments, |
| 210 | bool is_range, |
| 211 | uint32_t* args, |
| 212 | uint32_t register_index); |
| 213 | |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 214 | // Builds a new array node and the instructions that fill it. |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 215 | void BuildFilledNewArray(uint32_t dex_pc, |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 216 | uint32_t type_index, |
| 217 | uint32_t number_of_vreg_arguments, |
| 218 | bool is_range, |
| 219 | uint32_t* args, |
| 220 | uint32_t register_index); |
| 221 | |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 222 | void BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc); |
Calin Juravle | d0d4852 | 2014-11-04 16:40:20 +0000 | [diff] [blame] | 223 | |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 224 | // Fills the given object with data as specified in the fill-array-data |
| 225 | // instruction. Currently only used for non-reference and non-floating point |
| 226 | // arrays. |
| 227 | template <typename T> |
| 228 | void BuildFillArrayData(HInstruction* object, |
| 229 | const T* data, |
| 230 | uint32_t element_count, |
| 231 | Primitive::Type anticipated_type, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 232 | uint32_t dex_pc); |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 233 | |
| 234 | // Fills the given object with data as specified in the fill-array-data |
| 235 | // instruction. The data must be for long and double arrays. |
| 236 | void BuildFillWideArrayData(HInstruction* object, |
Nicolas Geoffray | 8d6ae52 | 2014-10-23 18:32:13 +0100 | [diff] [blame] | 237 | const int64_t* data, |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 238 | uint32_t element_count, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 239 | uint32_t dex_pc); |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 240 | |
Nicolas Geoffray | 57a88d4 | 2014-11-10 15:09:21 +0000 | [diff] [blame] | 241 | // Builds a `HInstanceOf`, or a `HCheckCast` instruction. |
Calin Juravle | 98893e1 | 2015-10-02 21:05:03 +0100 | [diff] [blame] | 242 | void BuildTypeCheck(const Instruction& instruction, |
Nicolas Geoffray | 57a88d4 | 2014-11-10 15:09:21 +0000 | [diff] [blame] | 243 | uint8_t destination, |
| 244 | uint8_t reference, |
| 245 | uint16_t type_index, |
Calin Juravle | 225ff81 | 2014-11-13 16:46:39 +0000 | [diff] [blame] | 246 | uint32_t dex_pc); |
Nicolas Geoffray | 57a88d4 | 2014-11-10 15:09:21 +0000 | [diff] [blame] | 247 | |
Andreas Gampe | e4d4d32 | 2014-12-04 09:09:57 -0800 | [diff] [blame] | 248 | // Builds an instruction sequence for a packed switch statement. |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 249 | void BuildPackedSwitch(const Instruction& instruction, uint32_t dex_pc); |
Andreas Gampe | d881df5 | 2014-11-24 23:28:39 -0800 | [diff] [blame] | 250 | |
Mark Mendell | fe57faa | 2015-09-18 09:26:15 -0400 | [diff] [blame] | 251 | // Build a switch instruction from a packed switch statement. |
| 252 | void BuildSwitchJumpTable(const SwitchTable& table, |
| 253 | const Instruction& instruction, |
| 254 | HInstruction* value, |
| 255 | uint32_t dex_pc); |
| 256 | |
Andreas Gampe | e4d4d32 | 2014-12-04 09:09:57 -0800 | [diff] [blame] | 257 | // Builds an instruction sequence for a sparse switch statement. |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 258 | void BuildSparseSwitch(const Instruction& instruction, uint32_t dex_pc); |
Andreas Gampe | e4d4d32 | 2014-12-04 09:09:57 -0800 | [diff] [blame] | 259 | |
| 260 | void BuildSwitchCaseHelper(const Instruction& instruction, size_t index, |
| 261 | bool is_last_case, const SwitchTable& table, |
| 262 | HInstruction* value, int32_t case_value_int, |
| 263 | int32_t target_offset, uint32_t dex_pc); |
| 264 | |
David Brazdil | 1b49872 | 2015-03-31 11:37:18 +0100 | [diff] [blame] | 265 | bool SkipCompilation(const DexFile::CodeItem& code_item, size_t number_of_branches); |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 266 | |
| 267 | void MaybeRecordStat(MethodCompilationStat compilation_stat); |
| 268 | |
Nicolas Geoffray | 3045174 | 2015-06-19 13:32:41 +0100 | [diff] [blame] | 269 | // Returns the outer-most compiling method's class. |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 270 | mirror::Class* GetOutermostCompilingClass() const; |
| 271 | |
Nicolas Geoffray | 3045174 | 2015-06-19 13:32:41 +0100 | [diff] [blame] | 272 | // Returns the class whose method is being compiled. |
| 273 | mirror::Class* GetCompilingClass() const; |
| 274 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 275 | // 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] | 276 | bool IsOutermostCompilingClass(uint16_t type_index) const; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 277 | |
Nicolas Geoffray | 2e7cd75 | 2015-07-10 11:38:52 +0100 | [diff] [blame] | 278 | void PotentiallySimplifyFakeString(uint16_t original_dex_register, |
| 279 | uint32_t dex_pc, |
| 280 | HInvoke* invoke); |
| 281 | |
Calin Juravle | 5d01db1 | 2015-08-25 15:02:42 +0100 | [diff] [blame] | 282 | bool SetupInvokeArguments(HInvoke* invoke, |
| 283 | uint32_t number_of_vreg_arguments, |
| 284 | uint32_t* args, |
| 285 | uint32_t register_index, |
| 286 | bool is_range, |
| 287 | const char* descriptor, |
| 288 | size_t start_index, |
| 289 | size_t* argument_index); |
| 290 | |
| 291 | bool HandleInvoke(HInvoke* invoke, |
| 292 | uint32_t number_of_vreg_arguments, |
| 293 | uint32_t* args, |
| 294 | uint32_t register_index, |
| 295 | bool is_range, |
| 296 | const char* descriptor, |
| 297 | HClinitCheck* clinit_check); |
| 298 | |
| 299 | bool HandleStringInit(HInvoke* invoke, |
| 300 | uint32_t number_of_vreg_arguments, |
| 301 | uint32_t* args, |
| 302 | uint32_t register_index, |
| 303 | bool is_range, |
| 304 | const char* descriptor); |
Calin Juravle | 68ad649 | 2015-08-18 17:08:12 +0100 | [diff] [blame] | 305 | |
| 306 | HClinitCheck* ProcessClinitCheckForInvoke( |
| 307 | uint32_t dex_pc, |
| 308 | uint32_t method_idx, |
| 309 | HInvokeStaticOrDirect::ClinitCheckRequirement* clinit_check_requirement); |
| 310 | |
Nicolas Geoffray | 729645a | 2015-11-19 13:29:02 +0000 | [diff] [blame] | 311 | // Build a HNewInstance instruction. |
| 312 | bool BuildNewInstance(uint16_t type_index, uint32_t dex_pc); |
| 313 | |
Nicolas Geoffray | d9dc6f4 | 2015-11-24 14:06:57 +0000 | [diff] [blame] | 314 | // Return whether the compiler can assume `cls` is initialized. |
| 315 | bool IsInitialized(Handle<mirror::Class> cls) const |
Nicolas Geoffray | 729645a | 2015-11-19 13:29:02 +0000 | [diff] [blame] | 316 | SHARED_REQUIRES(Locks::mutator_lock_); |
| 317 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 318 | ArenaAllocator* const arena_; |
Nicolas Geoffray | be9a92a | 2014-02-25 14:22:56 +0000 | [diff] [blame] | 319 | |
| 320 | // A list of the size of the dex code holding block information for |
| 321 | // the method. If an entry contains a block, then the dex instruction |
| 322 | // starting at that entry is the first instruction of a new block. |
Vladimir Marko | 2aaa4b5 | 2015-09-17 17:03:26 +0100 | [diff] [blame] | 323 | ArenaVector<HBasicBlock*> branch_targets_; |
Nicolas Geoffray | be9a92a | 2014-02-25 14:22:56 +0000 | [diff] [blame] | 324 | |
Vladimir Marko | 2aaa4b5 | 2015-09-17 17:03:26 +0100 | [diff] [blame] | 325 | ArenaVector<HLocal*> locals_; |
Nicolas Geoffray | 3ff386a | 2014-03-04 14:46:47 +0000 | [diff] [blame] | 326 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 327 | HBasicBlock* entry_block_; |
| 328 | HBasicBlock* exit_block_; |
| 329 | HBasicBlock* current_block_; |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 330 | HGraph* const graph_; |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 331 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 332 | // The dex file where the method being compiled is. |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 333 | const DexFile* const dex_file_; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 334 | |
| 335 | // The compilation unit of the current method being compiled. Note that |
| 336 | // it can be an inlined method. |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 337 | DexCompilationUnit* const dex_compilation_unit_; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 338 | |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 339 | CompilerDriver* const compiler_driver_; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 340 | |
| 341 | // The compilation unit of the outermost method being compiled. That is the |
| 342 | // method being compiled (and not inlined), and potentially inlining other |
| 343 | // methods. |
| 344 | const DexCompilationUnit* const outer_compilation_unit_; |
| 345 | |
| 346 | // The return type of the method being compiled. |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 347 | const Primitive::Type return_type_; |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 348 | |
Nicolas Geoffray | a3d05a4 | 2014-10-20 17:41:32 +0100 | [diff] [blame] | 349 | // The pointer in the dex file where the instructions of the code item |
| 350 | // being currently compiled start. |
| 351 | const uint16_t* code_start_; |
| 352 | |
| 353 | // The last invoke or fill-new-array being built. Only to be |
| 354 | // used by move-result instructions. |
| 355 | HInstruction* latest_result_; |
| 356 | |
Nicolas Geoffray | 2e7cd75 | 2015-07-10 11:38:52 +0100 | [diff] [blame] | 357 | // We need to know whether we have built a graph that has calls to StringFactory |
| 358 | // and hasn't gone through the verifier. If the following flag is `false`, then |
| 359 | // we cannot compile with baseline. |
| 360 | bool can_use_baseline_for_string_init_; |
| 361 | |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 362 | OptimizingCompilerStats* compilation_stats_; |
| 363 | |
Nicolas Geoffray | 9523a3e | 2015-07-17 11:51:28 +0000 | [diff] [blame] | 364 | const uint8_t* interpreter_metadata_; |
| 365 | |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 366 | // Dex cache for dex_file_. |
| 367 | Handle<mirror::DexCache> dex_cache_; |
| 368 | |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 369 | DISALLOW_COPY_AND_ASSIGN(HGraphBuilder); |
| 370 | }; |
| 371 | |
| 372 | } // namespace art |
| 373 | |
| 374 | #endif // ART_COMPILER_OPTIMIZING_BUILDER_H_ |