1 /*
2  * Copyright (C) 2016 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_INSTRUCTION_BUILDER_H_
18 #define ART_COMPILER_OPTIMIZING_INSTRUCTION_BUILDER_H_
19 
20 #include "base/array_ref.h"
21 #include "base/scoped_arena_allocator.h"
22 #include "base/scoped_arena_containers.h"
23 #include "data_type.h"
24 #include "dex/code_item_accessors.h"
25 #include "dex/dex_file.h"
26 #include "dex/dex_file_types.h"
27 #include "handle.h"
28 #include "nodes.h"
29 #include "quicken_info.h"
30 
31 namespace art {
32 
33 class ArenaBitVector;
34 class ArtField;
35 class ArtMethod;
36 class CodeGenerator;
37 class CompilerDriver;
38 class DexCompilationUnit;
39 class HBasicBlockBuilder;
40 class Instruction;
41 class OptimizingCompilerStats;
42 class SsaBuilder;
43 class VariableSizedHandleScope;
44 
45 namespace mirror {
46 class Class;
47 }  // namespace mirror
48 
49 class HInstructionBuilder : public ValueObject {
50  public:
51   HInstructionBuilder(HGraph* graph,
52                       HBasicBlockBuilder* block_builder,
53                       SsaBuilder* ssa_builder,
54                       const DexFile* dex_file,
55                       const CodeItemDebugInfoAccessor& accessor,
56                       DataType::Type return_type,
57                       const DexCompilationUnit* dex_compilation_unit,
58                       const DexCompilationUnit* outer_compilation_unit,
59                       CompilerDriver* compiler_driver,
60                       CodeGenerator* code_generator,
61                       ArrayRef<const uint8_t> interpreter_metadata,
62                       OptimizingCompilerStats* compiler_stats,
63                       VariableSizedHandleScope* handles,
64                       ScopedArenaAllocator* local_allocator);
65 
66   bool Build();
67   void BuildIntrinsic(ArtMethod* method);
68 
69  private:
70   void InitializeBlockLocals();
71   void PropagateLocalsToCatchBlocks();
72   void SetLoopHeaderPhiInputs();
73 
74   bool ProcessDexInstruction(const Instruction& instruction, uint32_t dex_pc, size_t quicken_index);
75   ArenaBitVector* FindNativeDebugInfoLocations();
76 
77   bool CanDecodeQuickenedInfo() const;
78   uint16_t LookupQuickenedInfo(uint32_t quicken_index);
79 
80   HBasicBlock* FindBlockStartingAt(uint32_t dex_pc) const;
81 
82   ScopedArenaVector<HInstruction*>* GetLocalsFor(HBasicBlock* block);
83   // Out of line version of GetLocalsFor(), which has a fast path that is
84   // beneficial to get inlined by callers.
85   ScopedArenaVector<HInstruction*>* GetLocalsForWithAllocation(
86       HBasicBlock* block, ScopedArenaVector<HInstruction*>* locals, const size_t vregs);
87   HInstruction* ValueOfLocalAt(HBasicBlock* block, size_t local);
88   HInstruction* LoadLocal(uint32_t register_index, DataType::Type type) const;
89   HInstruction* LoadNullCheckedLocal(uint32_t register_index, uint32_t dex_pc);
90   void UpdateLocal(uint32_t register_index, HInstruction* instruction);
91 
92   void AppendInstruction(HInstruction* instruction);
93   void InsertInstructionAtTop(HInstruction* instruction);
94   void InitializeInstruction(HInstruction* instruction);
95 
96   void InitializeParameters();
97 
98   // Returns whether the current method needs access check for the type.
99   // Output parameter finalizable is set to whether the type is finalizable.
100   bool NeedsAccessCheck(dex::TypeIndex type_index, /*out*/bool* finalizable) const
101       REQUIRES_SHARED(Locks::mutator_lock_);
102 
103   template<typename T>
104   void Unop_12x(const Instruction& instruction, DataType::Type type, uint32_t dex_pc);
105 
106   template<typename T>
107   void Binop_23x(const Instruction& instruction, DataType::Type type, uint32_t dex_pc);
108 
109   template<typename T>
110   void Binop_23x_shift(const Instruction& instruction, DataType::Type type, uint32_t dex_pc);
111 
112   void Binop_23x_cmp(const Instruction& instruction,
113                      DataType::Type type,
114                      ComparisonBias bias,
115                      uint32_t dex_pc);
116 
117   template<typename T>
118   void Binop_12x(const Instruction& instruction, DataType::Type type, uint32_t dex_pc);
119 
120   template<typename T>
121   void Binop_12x_shift(const Instruction& instruction, DataType::Type type, uint32_t dex_pc);
122 
123   template<typename T>
124   void Binop_22b(const Instruction& instruction, bool reverse, uint32_t dex_pc);
125 
126   template<typename T>
127   void Binop_22s(const Instruction& instruction, bool reverse, uint32_t dex_pc);
128 
129   template<typename T> void If_21t(const Instruction& instruction, uint32_t dex_pc);
130   template<typename T> void If_22t(const Instruction& instruction, uint32_t dex_pc);
131 
132   void Conversion_12x(const Instruction& instruction,
133                       DataType::Type input_type,
134                       DataType::Type result_type,
135                       uint32_t dex_pc);
136 
137   void BuildCheckedDivRem(uint16_t out_reg,
138                           uint16_t first_reg,
139                           int64_t second_reg_or_constant,
140                           uint32_t dex_pc,
141                           DataType::Type type,
142                           bool second_is_lit,
143                           bool is_div);
144 
145   void BuildReturn(const Instruction& instruction, DataType::Type type, uint32_t dex_pc);
146 
147   // Builds an instance field access node and returns whether the instruction is supported.
148   bool BuildInstanceFieldAccess(const Instruction& instruction,
149                                 uint32_t dex_pc,
150                                 bool is_put,
151                                 size_t quicken_index);
152 
153   void BuildUnresolvedStaticFieldAccess(const Instruction& instruction,
154                                         uint32_t dex_pc,
155                                         bool is_put,
156                                         DataType::Type field_type);
157   // Builds a static field access node.
158   void BuildStaticFieldAccess(const Instruction& instruction, uint32_t dex_pc, bool is_put);
159 
160   void BuildArrayAccess(const Instruction& instruction,
161                         uint32_t dex_pc,
162                         bool is_get,
163                         DataType::Type anticipated_type);
164 
165   // Builds an invocation node and returns whether the instruction is supported.
166   bool BuildInvoke(const Instruction& instruction,
167                    uint32_t dex_pc,
168                    uint32_t method_idx,
169                    uint32_t number_of_vreg_arguments,
170                    bool is_range,
171                    uint32_t* args,
172                    uint32_t register_index);
173 
174   // Builds an invocation node for invoke-polymorphic and returns whether the
175   // instruction is supported.
176   bool BuildInvokePolymorphic(const Instruction& instruction,
177                               uint32_t dex_pc,
178                               uint32_t method_idx,
179                               uint32_t proto_idx,
180                               uint32_t number_of_vreg_arguments,
181                               bool is_range,
182                               uint32_t* args,
183                               uint32_t register_index);
184 
185   // Builds a new array node and the instructions that fill it.
186   HNewArray* BuildFilledNewArray(uint32_t dex_pc,
187                                  dex::TypeIndex type_index,
188                                  uint32_t number_of_vreg_arguments,
189                                  bool is_range,
190                                  uint32_t* args,
191                                  uint32_t register_index);
192 
193   void BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc);
194 
195   // Fills the given object with data as specified in the fill-array-data
196   // instruction. Currently only used for non-reference and non-floating point
197   // arrays.
198   template <typename T>
199   void BuildFillArrayData(HInstruction* object,
200                           const T* data,
201                           uint32_t element_count,
202                           DataType::Type anticipated_type,
203                           uint32_t dex_pc);
204 
205   // Fills the given object with data as specified in the fill-array-data
206   // instruction. The data must be for long and double arrays.
207   void BuildFillWideArrayData(HInstruction* object,
208                               const int64_t* data,
209                               uint32_t element_count,
210                               uint32_t dex_pc);
211 
212   // Builds a `HInstanceOf`, or a `HCheckCast` instruction.
213   void BuildTypeCheck(const Instruction& instruction,
214                       uint8_t destination,
215                       uint8_t reference,
216                       dex::TypeIndex type_index,
217                       uint32_t dex_pc);
218 
219   // Builds an instruction sequence for a switch statement.
220   void BuildSwitch(const Instruction& instruction, uint32_t dex_pc);
221 
222   // Builds a `HLoadString` loading the given `string_index`.
223   void BuildLoadString(dex::StringIndex string_index, uint32_t dex_pc);
224 
225   // Builds a `HLoadClass` loading the given `type_index`.
226   HLoadClass* BuildLoadClass(dex::TypeIndex type_index, uint32_t dex_pc);
227 
228   HLoadClass* BuildLoadClass(dex::TypeIndex type_index,
229                              const DexFile& dex_file,
230                              Handle<mirror::Class> klass,
231                              uint32_t dex_pc,
232                              bool needs_access_check)
233       REQUIRES_SHARED(Locks::mutator_lock_);
234 
235   // Returns the outer-most compiling method's class.
236   ObjPtr<mirror::Class> GetOutermostCompilingClass() const;
237 
238   // Returns the class whose method is being compiled.
239   ObjPtr<mirror::Class> GetCompilingClass() const;
240 
241   // Returns whether `type_index` points to the outer-most compiling method's class.
242   bool IsOutermostCompilingClass(dex::TypeIndex type_index) const;
243 
244   void PotentiallySimplifyFakeString(uint16_t original_dex_register,
245                                      uint32_t dex_pc,
246                                      HInvoke* invoke);
247 
248   bool SetupInvokeArguments(HInvoke* invoke,
249                             uint32_t number_of_vreg_arguments,
250                             uint32_t* args,
251                             uint32_t register_index,
252                             bool is_range,
253                             const char* descriptor,
254                             size_t start_index,
255                             size_t* argument_index);
256 
257   bool HandleInvoke(HInvoke* invoke,
258                     uint32_t number_of_vreg_arguments,
259                     uint32_t* args,
260                     uint32_t register_index,
261                     bool is_range,
262                     const char* descriptor,
263                     HClinitCheck* clinit_check,
264                     bool is_unresolved);
265 
266   bool HandleStringInit(HInvoke* invoke,
267                         uint32_t number_of_vreg_arguments,
268                         uint32_t* args,
269                         uint32_t register_index,
270                         bool is_range,
271                         const char* descriptor);
272   void HandleStringInitResult(HInvokeStaticOrDirect* invoke);
273 
274   HClinitCheck* ProcessClinitCheckForInvoke(
275       uint32_t dex_pc,
276       ArtMethod* method,
277       HInvokeStaticOrDirect::ClinitCheckRequirement* clinit_check_requirement)
278       REQUIRES_SHARED(Locks::mutator_lock_);
279 
280   // Build a HNewInstance instruction.
281   HNewInstance* BuildNewInstance(dex::TypeIndex type_index, uint32_t dex_pc);
282 
283   // Build a HConstructorFence for HNewInstance and HNewArray instructions. This ensures the
284   // happens-before ordering for default-initialization of the object referred to by new_instance.
285   void BuildConstructorFenceForAllocation(HInstruction* allocation);
286 
287   // Return whether the compiler can assume `cls` is initialized.
288   bool IsInitialized(Handle<mirror::Class> cls) const
289       REQUIRES_SHARED(Locks::mutator_lock_);
290 
291   // Try to resolve a method using the class linker. Return null if a method could
292   // not be resolved.
293   ArtMethod* ResolveMethod(uint16_t method_idx, InvokeType invoke_type);
294 
295   // Try to resolve a field using the class linker. Return null if it could not
296   // be found.
297   ArtField* ResolveField(uint16_t field_idx, bool is_static, bool is_put);
298 
299   ObjPtr<mirror::Class> LookupResolvedType(dex::TypeIndex type_index,
300                                            const DexCompilationUnit& compilation_unit) const
301       REQUIRES_SHARED(Locks::mutator_lock_);
302 
303   ObjPtr<mirror::Class> LookupReferrerClass() const REQUIRES_SHARED(Locks::mutator_lock_);
304 
305   ArenaAllocator* const allocator_;
306   HGraph* const graph_;
307   VariableSizedHandleScope* const handles_;
308 
309   // The dex file where the method being compiled is, and the bytecode data.
310   const DexFile* const dex_file_;
311   const CodeItemDebugInfoAccessor code_item_accessor_;  // null for intrinsic graph.
312 
313   // The return type of the method being compiled.
314   const DataType::Type return_type_;
315 
316   HBasicBlockBuilder* const block_builder_;
317   SsaBuilder* const ssa_builder_;
318 
319   CompilerDriver* const compiler_driver_;
320 
321   CodeGenerator* const code_generator_;
322 
323   // The compilation unit of the current method being compiled. Note that
324   // it can be an inlined method.
325   const DexCompilationUnit* const dex_compilation_unit_;
326 
327   // The compilation unit of the outermost method being compiled. That is the
328   // method being compiled (and not inlined), and potentially inlining other
329   // methods.
330   const DexCompilationUnit* const outer_compilation_unit_;
331 
332   // Original values kept after instruction quickening.
333   QuickenInfoTable quicken_info_;
334 
335   OptimizingCompilerStats* const compilation_stats_;
336 
337   ScopedArenaAllocator* const local_allocator_;
338   ScopedArenaVector<ScopedArenaVector<HInstruction*>> locals_for_;
339   HBasicBlock* current_block_;
340   ScopedArenaVector<HInstruction*>* current_locals_;
341   HInstruction* latest_result_;
342   // Current "this" parameter.
343   // Valid only after InitializeParameters() finishes.
344   // * Null for static methods.
345   // * Non-null for instance methods.
346   HParameterValue* current_this_parameter_;
347 
348   ScopedArenaVector<HBasicBlock*> loop_headers_;
349 
350   static constexpr int kDefaultNumberOfLoops = 2;
351 
352   DISALLOW_COPY_AND_ASSIGN(HInstructionBuilder);
353 };
354 
355 }  // namespace art
356 
357 #endif  // ART_COMPILER_OPTIMIZING_INSTRUCTION_BUILDER_H_
358