quick_compiler.cc revision 3773cd046b1c34569f4711666788bf8a389c7857 
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#include "quick_compiler.h"
18
19#include <cstdint>
20
21#include "base/dumpable.h"
22#include "base/logging.h"
23#include "base/macros.h"
24#include "base/timing_logger.h"
25#include "compiler.h"
26#include "dex_file-inl.h"
27#include "dex_file_to_method_inliner_map.h"
28#include "dex/compiler_ir.h"
29#include "dex/dex_flags.h"
30#include "dex/mir_graph.h"
31#include "dex/pass_driver_me_opts.h"
32#include "dex/pass_driver_me_post_opt.h"
33#include "dex/pass_manager.h"
34#include "dex/quick/mir_to_lir.h"
35#include "driver/compiler_driver.h"
36#include "driver/compiler_options.h"
37#include "elf_writer_quick.h"
38#include "jni/quick/jni_compiler.h"
39#include "mir_to_lir.h"
40#include "mirror/art_method-inl.h"
41#include "mirror/object.h"
42#include "runtime.h"
43
44// Specific compiler backends.
45#include "dex/quick/arm/backend_arm.h"
46#include "dex/quick/arm64/backend_arm64.h"
47#include "dex/quick/mips/backend_mips.h"
48#include "dex/quick/x86/backend_x86.h"
49
50namespace art {
51
52static_assert(0U == static_cast<size_t>(kNone),   "kNone not 0");
53static_assert(1U == static_cast<size_t>(kArm),    "kArm not 1");
54static_assert(2U == static_cast<size_t>(kArm64),  "kArm64 not 2");
55static_assert(3U == static_cast<size_t>(kThumb2), "kThumb2 not 3");
56static_assert(4U == static_cast<size_t>(kX86),    "kX86 not 4");
57static_assert(5U == static_cast<size_t>(kX86_64), "kX86_64 not 5");
58static_assert(6U == static_cast<size_t>(kMips),   "kMips not 6");
59static_assert(7U == static_cast<size_t>(kMips64), "kMips64 not 7");
60
61// Additional disabled optimizations (over generally disabled) per instruction set.
62static constexpr uint32_t kDisabledOptimizationsPerISA[] = {
63    // 0 = kNone.
64    ~0U,
65    // 1 = kArm, unused (will use kThumb2).
66    ~0U,
67    // 2 = kArm64.
68    0,
69    // 3 = kThumb2.
70    0,
71    // 4 = kX86.
72    (1 << kLoadStoreElimination) |
73    0,
74    // 5 = kX86_64.
75    (1 << kLoadStoreElimination) |
76    0,
77    // 6 = kMips.
78    (1 << kLoadStoreElimination) |
79    (1 << kLoadHoisting) |
80    (1 << kSuppressLoads) |
81    (1 << kNullCheckElimination) |
82    (1 << kPromoteRegs) |
83    (1 << kTrackLiveTemps) |
84    (1 << kSafeOptimizations) |
85    (1 << kBBOpt) |
86    (1 << kMatch) |
87    (1 << kPromoteCompilerTemps) |
88    0,
89    // 7 = kMips64.
90    (1 << kLoadStoreElimination) |
91    (1 << kLoadHoisting) |
92    (1 << kSuppressLoads) |
93    (1 << kNullCheckElimination) |
94    (1 << kPromoteRegs) |
95    (1 << kTrackLiveTemps) |
96    (1 << kSafeOptimizations) |
97    (1 << kBBOpt) |
98    (1 << kMatch) |
99    (1 << kPromoteCompilerTemps) |
100    0
101};
102static_assert(sizeof(kDisabledOptimizationsPerISA) == 8 * sizeof(uint32_t),
103              "kDisabledOpts unexpected");
104
105// Supported shorty types per instruction set. nullptr means that all are available.
106// Z : boolean
107// B : byte
108// S : short
109// C : char
110// I : int
111// J : long
112// F : float
113// D : double
114// L : reference(object, array)
115// V : void
116static const char* kSupportedTypes[] = {
117    // 0 = kNone.
118    "",
119    // 1 = kArm, unused (will use kThumb2).
120    "",
121    // 2 = kArm64.
122    nullptr,
123    // 3 = kThumb2.
124    nullptr,
125    // 4 = kX86.
126    nullptr,
127    // 5 = kX86_64.
128    nullptr,
129    // 6 = kMips.
130    nullptr,
131    // 7 = kMips64.
132    nullptr
133};
134static_assert(sizeof(kSupportedTypes) == 8 * sizeof(char*), "kSupportedTypes unexpected");
135
136static int kAllOpcodes[] = {
137    Instruction::NOP,
138    Instruction::MOVE,
139    Instruction::MOVE_FROM16,
140    Instruction::MOVE_16,
141    Instruction::MOVE_WIDE,
142    Instruction::MOVE_WIDE_FROM16,
143    Instruction::MOVE_WIDE_16,
144    Instruction::MOVE_OBJECT,
145    Instruction::MOVE_OBJECT_FROM16,
146    Instruction::MOVE_OBJECT_16,
147    Instruction::MOVE_RESULT,
148    Instruction::MOVE_RESULT_WIDE,
149    Instruction::MOVE_RESULT_OBJECT,
150    Instruction::MOVE_EXCEPTION,
151    Instruction::RETURN_VOID,
152    Instruction::RETURN,
153    Instruction::RETURN_WIDE,
154    Instruction::RETURN_OBJECT,
155    Instruction::CONST_4,
156    Instruction::CONST_16,
157    Instruction::CONST,
158    Instruction::CONST_HIGH16,
159    Instruction::CONST_WIDE_16,
160    Instruction::CONST_WIDE_32,
161    Instruction::CONST_WIDE,
162    Instruction::CONST_WIDE_HIGH16,
163    Instruction::CONST_STRING,
164    Instruction::CONST_STRING_JUMBO,
165    Instruction::CONST_CLASS,
166    Instruction::MONITOR_ENTER,
167    Instruction::MONITOR_EXIT,
168    Instruction::CHECK_CAST,
169    Instruction::INSTANCE_OF,
170    Instruction::ARRAY_LENGTH,
171    Instruction::NEW_INSTANCE,
172    Instruction::NEW_ARRAY,
173    Instruction::FILLED_NEW_ARRAY,
174    Instruction::FILLED_NEW_ARRAY_RANGE,
175    Instruction::FILL_ARRAY_DATA,
176    Instruction::THROW,
177    Instruction::GOTO,
178    Instruction::GOTO_16,
179    Instruction::GOTO_32,
180    Instruction::PACKED_SWITCH,
181    Instruction::SPARSE_SWITCH,
182    Instruction::CMPL_FLOAT,
183    Instruction::CMPG_FLOAT,
184    Instruction::CMPL_DOUBLE,
185    Instruction::CMPG_DOUBLE,
186    Instruction::CMP_LONG,
187    Instruction::IF_EQ,
188    Instruction::IF_NE,
189    Instruction::IF_LT,
190    Instruction::IF_GE,
191    Instruction::IF_GT,
192    Instruction::IF_LE,
193    Instruction::IF_EQZ,
194    Instruction::IF_NEZ,
195    Instruction::IF_LTZ,
196    Instruction::IF_GEZ,
197    Instruction::IF_GTZ,
198    Instruction::IF_LEZ,
199    Instruction::UNUSED_3E,
200    Instruction::UNUSED_3F,
201    Instruction::UNUSED_40,
202    Instruction::UNUSED_41,
203    Instruction::UNUSED_42,
204    Instruction::UNUSED_43,
205    Instruction::AGET,
206    Instruction::AGET_WIDE,
207    Instruction::AGET_OBJECT,
208    Instruction::AGET_BOOLEAN,
209    Instruction::AGET_BYTE,
210    Instruction::AGET_CHAR,
211    Instruction::AGET_SHORT,
212    Instruction::APUT,
213    Instruction::APUT_WIDE,
214    Instruction::APUT_OBJECT,
215    Instruction::APUT_BOOLEAN,
216    Instruction::APUT_BYTE,
217    Instruction::APUT_CHAR,
218    Instruction::APUT_SHORT,
219    Instruction::IGET,
220    Instruction::IGET_WIDE,
221    Instruction::IGET_OBJECT,
222    Instruction::IGET_BOOLEAN,
223    Instruction::IGET_BYTE,
224    Instruction::IGET_CHAR,
225    Instruction::IGET_SHORT,
226    Instruction::IPUT,
227    Instruction::IPUT_WIDE,
228    Instruction::IPUT_OBJECT,
229    Instruction::IPUT_BOOLEAN,
230    Instruction::IPUT_BYTE,
231    Instruction::IPUT_CHAR,
232    Instruction::IPUT_SHORT,
233    Instruction::SGET,
234    Instruction::SGET_WIDE,
235    Instruction::SGET_OBJECT,
236    Instruction::SGET_BOOLEAN,
237    Instruction::SGET_BYTE,
238    Instruction::SGET_CHAR,
239    Instruction::SGET_SHORT,
240    Instruction::SPUT,
241    Instruction::SPUT_WIDE,
242    Instruction::SPUT_OBJECT,
243    Instruction::SPUT_BOOLEAN,
244    Instruction::SPUT_BYTE,
245    Instruction::SPUT_CHAR,
246    Instruction::SPUT_SHORT,
247    Instruction::INVOKE_VIRTUAL,
248    Instruction::INVOKE_SUPER,
249    Instruction::INVOKE_DIRECT,
250    Instruction::INVOKE_STATIC,
251    Instruction::INVOKE_INTERFACE,
252    Instruction::RETURN_VOID_NO_BARRIER,
253    Instruction::INVOKE_VIRTUAL_RANGE,
254    Instruction::INVOKE_SUPER_RANGE,
255    Instruction::INVOKE_DIRECT_RANGE,
256    Instruction::INVOKE_STATIC_RANGE,
257    Instruction::INVOKE_INTERFACE_RANGE,
258    Instruction::UNUSED_79,
259    Instruction::UNUSED_7A,
260    Instruction::NEG_INT,
261    Instruction::NOT_INT,
262    Instruction::NEG_LONG,
263    Instruction::NOT_LONG,
264    Instruction::NEG_FLOAT,
265    Instruction::NEG_DOUBLE,
266    Instruction::INT_TO_LONG,
267    Instruction::INT_TO_FLOAT,
268    Instruction::INT_TO_DOUBLE,
269    Instruction::LONG_TO_INT,
270    Instruction::LONG_TO_FLOAT,
271    Instruction::LONG_TO_DOUBLE,
272    Instruction::FLOAT_TO_INT,
273    Instruction::FLOAT_TO_LONG,
274    Instruction::FLOAT_TO_DOUBLE,
275    Instruction::DOUBLE_TO_INT,
276    Instruction::DOUBLE_TO_LONG,
277    Instruction::DOUBLE_TO_FLOAT,
278    Instruction::INT_TO_BYTE,
279    Instruction::INT_TO_CHAR,
280    Instruction::INT_TO_SHORT,
281    Instruction::ADD_INT,
282    Instruction::SUB_INT,
283    Instruction::MUL_INT,
284    Instruction::DIV_INT,
285    Instruction::REM_INT,
286    Instruction::AND_INT,
287    Instruction::OR_INT,
288    Instruction::XOR_INT,
289    Instruction::SHL_INT,
290    Instruction::SHR_INT,
291    Instruction::USHR_INT,
292    Instruction::ADD_LONG,
293    Instruction::SUB_LONG,
294    Instruction::MUL_LONG,
295    Instruction::DIV_LONG,
296    Instruction::REM_LONG,
297    Instruction::AND_LONG,
298    Instruction::OR_LONG,
299    Instruction::XOR_LONG,
300    Instruction::SHL_LONG,
301    Instruction::SHR_LONG,
302    Instruction::USHR_LONG,
303    Instruction::ADD_FLOAT,
304    Instruction::SUB_FLOAT,
305    Instruction::MUL_FLOAT,
306    Instruction::DIV_FLOAT,
307    Instruction::REM_FLOAT,
308    Instruction::ADD_DOUBLE,
309    Instruction::SUB_DOUBLE,
310    Instruction::MUL_DOUBLE,
311    Instruction::DIV_DOUBLE,
312    Instruction::REM_DOUBLE,
313    Instruction::ADD_INT_2ADDR,
314    Instruction::SUB_INT_2ADDR,
315    Instruction::MUL_INT_2ADDR,
316    Instruction::DIV_INT_2ADDR,
317    Instruction::REM_INT_2ADDR,
318    Instruction::AND_INT_2ADDR,
319    Instruction::OR_INT_2ADDR,
320    Instruction::XOR_INT_2ADDR,
321    Instruction::SHL_INT_2ADDR,
322    Instruction::SHR_INT_2ADDR,
323    Instruction::USHR_INT_2ADDR,
324    Instruction::ADD_LONG_2ADDR,
325    Instruction::SUB_LONG_2ADDR,
326    Instruction::MUL_LONG_2ADDR,
327    Instruction::DIV_LONG_2ADDR,
328    Instruction::REM_LONG_2ADDR,
329    Instruction::AND_LONG_2ADDR,
330    Instruction::OR_LONG_2ADDR,
331    Instruction::XOR_LONG_2ADDR,
332    Instruction::SHL_LONG_2ADDR,
333    Instruction::SHR_LONG_2ADDR,
334    Instruction::USHR_LONG_2ADDR,
335    Instruction::ADD_FLOAT_2ADDR,
336    Instruction::SUB_FLOAT_2ADDR,
337    Instruction::MUL_FLOAT_2ADDR,
338    Instruction::DIV_FLOAT_2ADDR,
339    Instruction::REM_FLOAT_2ADDR,
340    Instruction::ADD_DOUBLE_2ADDR,
341    Instruction::SUB_DOUBLE_2ADDR,
342    Instruction::MUL_DOUBLE_2ADDR,
343    Instruction::DIV_DOUBLE_2ADDR,
344    Instruction::REM_DOUBLE_2ADDR,
345    Instruction::ADD_INT_LIT16,
346    Instruction::RSUB_INT,
347    Instruction::MUL_INT_LIT16,
348    Instruction::DIV_INT_LIT16,
349    Instruction::REM_INT_LIT16,
350    Instruction::AND_INT_LIT16,
351    Instruction::OR_INT_LIT16,
352    Instruction::XOR_INT_LIT16,
353    Instruction::ADD_INT_LIT8,
354    Instruction::RSUB_INT_LIT8,
355    Instruction::MUL_INT_LIT8,
356    Instruction::DIV_INT_LIT8,
357    Instruction::REM_INT_LIT8,
358    Instruction::AND_INT_LIT8,
359    Instruction::OR_INT_LIT8,
360    Instruction::XOR_INT_LIT8,
361    Instruction::SHL_INT_LIT8,
362    Instruction::SHR_INT_LIT8,
363    Instruction::USHR_INT_LIT8,
364    Instruction::IGET_QUICK,
365    Instruction::IGET_WIDE_QUICK,
366    Instruction::IGET_OBJECT_QUICK,
367    Instruction::IPUT_QUICK,
368    Instruction::IPUT_WIDE_QUICK,
369    Instruction::IPUT_OBJECT_QUICK,
370    Instruction::INVOKE_VIRTUAL_QUICK,
371    Instruction::INVOKE_VIRTUAL_RANGE_QUICK,
372    Instruction::IPUT_BOOLEAN_QUICK,
373    Instruction::IPUT_BYTE_QUICK,
374    Instruction::IPUT_CHAR_QUICK,
375    Instruction::IPUT_SHORT_QUICK,
376    Instruction::IGET_BOOLEAN_QUICK,
377    Instruction::IGET_BYTE_QUICK,
378    Instruction::IGET_CHAR_QUICK,
379    Instruction::IGET_SHORT_QUICK,
380    Instruction::UNUSED_F3,
381    Instruction::UNUSED_F4,
382    Instruction::UNUSED_F5,
383    Instruction::UNUSED_F6,
384    Instruction::UNUSED_F7,
385    Instruction::UNUSED_F8,
386    Instruction::UNUSED_F9,
387    Instruction::UNUSED_FA,
388    Instruction::UNUSED_FB,
389    Instruction::UNUSED_FC,
390    Instruction::UNUSED_FD,
391    Instruction::UNUSED_FE,
392    Instruction::UNUSED_FF,
393    // ----- ExtendedMIROpcode -----
394    kMirOpPhi,
395    kMirOpCopy,
396    kMirOpFusedCmplFloat,
397    kMirOpFusedCmpgFloat,
398    kMirOpFusedCmplDouble,
399    kMirOpFusedCmpgDouble,
400    kMirOpFusedCmpLong,
401    kMirOpNop,
402    kMirOpNullCheck,
403    kMirOpRangeCheck,
404    kMirOpDivZeroCheck,
405    kMirOpCheck,
406    kMirOpCheckPart2,
407    kMirOpSelect,
408};
409
410static int kInvokeOpcodes[] = {
411    Instruction::INVOKE_VIRTUAL,
412    Instruction::INVOKE_SUPER,
413    Instruction::INVOKE_DIRECT,
414    Instruction::INVOKE_STATIC,
415    Instruction::INVOKE_INTERFACE,
416    Instruction::INVOKE_VIRTUAL_RANGE,
417    Instruction::INVOKE_SUPER_RANGE,
418    Instruction::INVOKE_DIRECT_RANGE,
419    Instruction::INVOKE_STATIC_RANGE,
420    Instruction::INVOKE_INTERFACE_RANGE,
421    Instruction::INVOKE_VIRTUAL_QUICK,
422    Instruction::INVOKE_VIRTUAL_RANGE_QUICK,
423};
424
425// Unsupported opcodes. nullptr can be used when everything is supported. Size of the lists is
426// recorded below.
427static const int* kUnsupportedOpcodes[] = {
428    // 0 = kNone.
429    kAllOpcodes,
430    // 1 = kArm, unused (will use kThumb2).
431    kAllOpcodes,
432    // 2 = kArm64.
433    nullptr,
434    // 3 = kThumb2.
435    nullptr,
436    // 4 = kX86.
437    nullptr,
438    // 5 = kX86_64.
439    nullptr,
440    // 6 = kMips.
441    nullptr,
442    // 7 = kMips64.
443    nullptr
444};
445static_assert(sizeof(kUnsupportedOpcodes) == 8 * sizeof(int*), "kUnsupportedOpcodes unexpected");
446
447// Size of the arrays stored above.
448static const size_t kUnsupportedOpcodesSize[] = {
449    // 0 = kNone.
450    arraysize(kAllOpcodes),
451    // 1 = kArm, unused (will use kThumb2).
452    arraysize(kAllOpcodes),
453    // 2 = kArm64.
454    0,
455    // 3 = kThumb2.
456    0,
457    // 4 = kX86.
458    0,
459    // 5 = kX86_64.
460    0,
461    // 6 = kMips.
462    0,
463    // 7 = kMips64.
464    0
465};
466static_assert(sizeof(kUnsupportedOpcodesSize) == 8 * sizeof(size_t),
467              "kUnsupportedOpcodesSize unexpected");
468
469// The maximum amount of Dalvik register in a method for which we will start compiling. Tries to
470// avoid an abort when we need to manage more SSA registers than we can.
471static constexpr size_t kMaxAllowedDalvikRegisters = INT16_MAX / 2;
472
473static bool CanCompileShorty(const char* shorty, InstructionSet instruction_set) {
474  const char* supported_types = kSupportedTypes[instruction_set];
475  if (supported_types == nullptr) {
476    // Everything available.
477    return true;
478  }
479
480  uint32_t shorty_size = strlen(shorty);
481  CHECK_GE(shorty_size, 1u);
482
483  for (uint32_t i = 0; i < shorty_size; i++) {
484    if (strchr(supported_types, shorty[i]) == nullptr) {
485      return false;
486    }
487  }
488  return true;
489}
490
491// Skip the method that we do not support currently.
492bool QuickCompiler::CanCompileMethod(uint32_t method_idx, const DexFile& dex_file,
493                                     CompilationUnit* cu) const {
494  // This is a limitation in mir_graph. See MirGraph::SetNumSSARegs.
495  if (cu->mir_graph->GetNumOfCodeAndTempVRs() > kMaxAllowedDalvikRegisters) {
496    VLOG(compiler) << "Too many dalvik registers : " << cu->mir_graph->GetNumOfCodeAndTempVRs();
497    return false;
498  }
499
500  // Check whether we do have limitations at all.
501  if (kSupportedTypes[cu->instruction_set] == nullptr &&
502      kUnsupportedOpcodesSize[cu->instruction_set] == 0U) {
503    return true;
504  }
505
506  // Check if we can compile the prototype.
507  const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
508  if (!CanCompileShorty(shorty, cu->instruction_set)) {
509    VLOG(compiler) << "Unsupported shorty : " << shorty;
510    return false;
511  }
512
513  const int *unsupport_list = kUnsupportedOpcodes[cu->instruction_set];
514  int unsupport_list_size = kUnsupportedOpcodesSize[cu->instruction_set];
515
516  for (unsigned int idx = 0; idx < cu->mir_graph->GetNumBlocks(); idx++) {
517    BasicBlock* bb = cu->mir_graph->GetBasicBlock(idx);
518    if (bb == NULL) continue;
519    if (bb->block_type == kDead) continue;
520    for (MIR* mir = bb->first_mir_insn; mir != nullptr; mir = mir->next) {
521      int opcode = mir->dalvikInsn.opcode;
522      // Check if we support the byte code.
523      if (std::find(unsupport_list, unsupport_list + unsupport_list_size, opcode)
524          != unsupport_list + unsupport_list_size) {
525        if (!MIR::DecodedInstruction::IsPseudoMirOp(opcode)) {
526          VLOG(compiler) << "Unsupported dalvik byte code : "
527              << mir->dalvikInsn.opcode;
528        } else {
529          VLOG(compiler) << "Unsupported extended MIR opcode : "
530              << MIRGraph::extended_mir_op_names_[opcode - kMirOpFirst];
531        }
532        return false;
533      }
534      // Check if it invokes a prototype that we cannot support.
535      if (std::find(kInvokeOpcodes, kInvokeOpcodes + arraysize(kInvokeOpcodes), opcode)
536          != kInvokeOpcodes + arraysize(kInvokeOpcodes)) {
537        uint32_t invoke_method_idx = mir->dalvikInsn.vB;
538        const char* invoke_method_shorty = dex_file.GetMethodShorty(
539            dex_file.GetMethodId(invoke_method_idx));
540        if (!CanCompileShorty(invoke_method_shorty, cu->instruction_set)) {
541          VLOG(compiler) << "Unsupported to invoke '"
542              << PrettyMethod(invoke_method_idx, dex_file)
543              << "' with shorty : " << invoke_method_shorty;
544          return false;
545        }
546      }
547    }
548  }
549  return true;
550}
551
552void QuickCompiler::InitCompilationUnit(CompilationUnit& cu) const {
553  // Disable optimizations according to instruction set.
554  cu.disable_opt |= kDisabledOptimizationsPerISA[cu.instruction_set];
555  if (Runtime::Current()->UseJit()) {
556    // Disable these optimizations for JIT until quickened byte codes are done being implemented.
557    // TODO: Find a cleaner way to do this.
558    cu.disable_opt |= 1u << kLocalValueNumbering;
559  }
560}
561
562void QuickCompiler::Init() {
563  CHECK(GetCompilerDriver()->GetCompilerContext() == nullptr);
564}
565
566void QuickCompiler::UnInit() const {
567  CHECK(GetCompilerDriver()->GetCompilerContext() == nullptr);
568}
569
570/* Default optimizer/debug setting for the compiler. */
571static uint32_t kCompilerOptimizerDisableFlags = 0 |  // Disable specific optimizations
572  // (1 << kLoadStoreElimination) |
573  // (1 << kLoadHoisting) |
574  // (1 << kSuppressLoads) |
575  // (1 << kNullCheckElimination) |
576  // (1 << kClassInitCheckElimination) |
577  // (1 << kGlobalValueNumbering) |
578  (1 << kGvnDeadCodeElimination) |
579  // (1 << kLocalValueNumbering) |
580  // (1 << kPromoteRegs) |
581  // (1 << kTrackLiveTemps) |
582  // (1 << kSafeOptimizations) |
583  // (1 << kBBOpt) |
584  // (1 << kSuspendCheckElimination) |
585  // (1 << kMatch) |
586  // (1 << kPromoteCompilerTemps) |
587  // (1 << kSuppressExceptionEdges) |
588  // (1 << kSuppressMethodInlining) |
589  0;
590
591static uint32_t kCompilerDebugFlags = 0 |     // Enable debug/testing modes
592  // (1 << kDebugDisplayMissingTargets) |
593  // (1 << kDebugVerbose) |
594  // (1 << kDebugDumpCFG) |
595  // (1 << kDebugSlowFieldPath) |
596  // (1 << kDebugSlowInvokePath) |
597  // (1 << kDebugSlowStringPath) |
598  // (1 << kDebugSlowestFieldPath) |
599  // (1 << kDebugSlowestStringPath) |
600  // (1 << kDebugExerciseResolveMethod) |
601  // (1 << kDebugVerifyDataflow) |
602  // (1 << kDebugShowMemoryUsage) |
603  // (1 << kDebugShowNops) |
604  // (1 << kDebugCountOpcodes) |
605  // (1 << kDebugDumpCheckStats) |
606  // (1 << kDebugShowSummaryMemoryUsage) |
607  // (1 << kDebugShowFilterStats) |
608  // (1 << kDebugTimings) |
609  // (1 << kDebugCodegenDump) |
610  0;
611
612CompiledMethod* QuickCompiler::Compile(const DexFile::CodeItem* code_item,
613                                       uint32_t access_flags,
614                                       InvokeType invoke_type,
615                                       uint16_t class_def_idx,
616                                       uint32_t method_idx,
617                                       jobject class_loader,
618                                       const DexFile& dex_file) const {
619  // TODO: check method fingerprint here to determine appropriate backend type.  Until then, use
620  // build default.
621  CompilerDriver* driver = GetCompilerDriver();
622
623  VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
624  if (Compiler::IsPathologicalCase(*code_item, method_idx, dex_file)) {
625    return nullptr;
626  }
627
628  DCHECK(driver->GetCompilerOptions().IsCompilationEnabled());
629
630  Runtime* const runtime = Runtime::Current();
631  ClassLinker* const class_linker = runtime->GetClassLinker();
632  InstructionSet instruction_set = driver->GetInstructionSet();
633  if (instruction_set == kArm) {
634    instruction_set = kThumb2;
635  }
636  CompilationUnit cu(runtime->GetArenaPool(), instruction_set, driver, class_linker);
637  cu.dex_file = &dex_file;
638  cu.class_def_idx = class_def_idx;
639  cu.method_idx = method_idx;
640  cu.access_flags = access_flags;
641  cu.invoke_type = invoke_type;
642  cu.shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
643
644  CHECK((cu.instruction_set == kThumb2) ||
645        (cu.instruction_set == kArm64) ||
646        (cu.instruction_set == kX86) ||
647        (cu.instruction_set == kX86_64) ||
648        (cu.instruction_set == kMips) ||
649        (cu.instruction_set == kMips64));
650
651  // TODO: set this from command line
652  constexpr bool compiler_flip_match = false;
653  const std::string compiler_method_match = "";
654
655  bool use_match = !compiler_method_match.empty();
656  bool match = use_match && (compiler_flip_match ^
657      (PrettyMethod(method_idx, dex_file).find(compiler_method_match) != std::string::npos));
658  if (!use_match || match) {
659    cu.disable_opt = kCompilerOptimizerDisableFlags;
660    cu.enable_debug = kCompilerDebugFlags;
661    cu.verbose = VLOG_IS_ON(compiler) ||
662        (cu.enable_debug & (1 << kDebugVerbose));
663  }
664
665  if (driver->GetCompilerOptions().HasVerboseMethods()) {
666    cu.verbose = driver->GetCompilerOptions().IsVerboseMethod(PrettyMethod(method_idx, dex_file));
667  }
668
669  if (cu.verbose) {
670    cu.enable_debug |= (1 << kDebugCodegenDump);
671  }
672
673  /*
674   * TODO: rework handling of optimization and debug flags.  Should we split out
675   * MIR and backend flags?  Need command-line setting as well.
676   */
677
678  InitCompilationUnit(cu);
679
680  cu.StartTimingSplit("BuildMIRGraph");
681  cu.mir_graph.reset(new MIRGraph(&cu, &cu.arena));
682
683  /*
684   * After creation of the MIR graph, also create the code generator.
685   * The reason we do this is that optimizations on the MIR graph may need to get information
686   * that is only available if a CG exists.
687   */
688  cu.cg.reset(GetCodeGenerator(&cu, nullptr));
689
690  /* Gathering opcode stats? */
691  if (kCompilerDebugFlags & (1 << kDebugCountOpcodes)) {
692    cu.mir_graph->EnableOpcodeCounting();
693  }
694
695  /* Build the raw MIR graph */
696  cu.mir_graph->InlineMethod(code_item, access_flags, invoke_type, class_def_idx, method_idx,
697                             class_loader, dex_file);
698
699  if (!CanCompileMethod(method_idx, dex_file, &cu)) {
700    VLOG(compiler)  << cu.instruction_set << ": Cannot compile method : "
701        << PrettyMethod(method_idx, dex_file);
702    cu.EndTiming();
703    return nullptr;
704  }
705
706  cu.NewTimingSplit("MIROpt:CheckFilters");
707  std::string skip_message;
708  if (cu.mir_graph->SkipCompilation(&skip_message)) {
709    VLOG(compiler) << cu.instruction_set << ": Skipping method : "
710        << PrettyMethod(method_idx, dex_file) << "  Reason = " << skip_message;
711    cu.EndTiming();
712    return nullptr;
713  }
714
715  /* Create the pass driver and launch it */
716  PassDriverMEOpts pass_driver(GetPreOptPassManager(), GetPostOptPassManager(), &cu);
717  pass_driver.Launch();
718
719  /* For non-leaf methods check if we should skip compilation when the profiler is enabled. */
720  if (cu.compiler_driver->ProfilePresent()
721      && !cu.mir_graph->MethodIsLeaf()
722      && cu.mir_graph->SkipCompilationByName(PrettyMethod(method_idx, dex_file))) {
723    cu.EndTiming();
724    return nullptr;
725  }
726
727  if (cu.enable_debug & (1 << kDebugDumpCheckStats)) {
728    cu.mir_graph->DumpCheckStats();
729  }
730
731  if (kCompilerDebugFlags & (1 << kDebugCountOpcodes)) {
732    cu.mir_graph->ShowOpcodeStats();
733  }
734
735  /* Reassociate sreg names with original Dalvik vreg names. */
736  cu.mir_graph->RemapRegLocations();
737
738  /* Free Arenas from the cu.arena_stack for reuse by the cu.arena in the codegen. */
739  if (cu.enable_debug & (1 << kDebugShowMemoryUsage)) {
740    if (cu.arena_stack.PeakBytesAllocated() > 1 * 1024 * 1024) {
741      MemStats stack_stats(cu.arena_stack.GetPeakStats());
742      LOG(INFO) << PrettyMethod(method_idx, dex_file) << " " << Dumpable<MemStats>(stack_stats);
743    }
744  }
745  cu.arena_stack.Reset();
746
747  CompiledMethod* result = nullptr;
748
749  if (cu.mir_graph->PuntToInterpreter()) {
750    VLOG(compiler) << cu.instruction_set << ": Punted method to interpreter: "
751        << PrettyMethod(method_idx, dex_file);
752    cu.EndTiming();
753    return nullptr;
754  }
755
756  cu.cg->Materialize();
757
758  cu.NewTimingSplit("Dedupe");  /* deduping takes up the vast majority of time in GetCompiledMethod(). */
759  result = cu.cg->GetCompiledMethod();
760  cu.NewTimingSplit("Cleanup");
761
762  if (result) {
763    VLOG(compiler) << cu.instruction_set << ": Compiled " << PrettyMethod(method_idx, dex_file);
764  } else {
765    VLOG(compiler) << cu.instruction_set << ": Deferred " << PrettyMethod(method_idx, dex_file);
766  }
767
768  if (cu.enable_debug & (1 << kDebugShowMemoryUsage)) {
769    if (cu.arena.BytesAllocated() > (1 * 1024 *1024)) {
770      MemStats mem_stats(cu.arena.GetMemStats());
771      LOG(INFO) << PrettyMethod(method_idx, dex_file) << " " << Dumpable<MemStats>(mem_stats);
772    }
773  }
774
775  if (cu.enable_debug & (1 << kDebugShowSummaryMemoryUsage)) {
776    LOG(INFO) << "MEMINFO " << cu.arena.BytesAllocated() << " " << cu.mir_graph->GetNumBlocks()
777                    << " " << PrettyMethod(method_idx, dex_file);
778  }
779
780  cu.EndTiming();
781  driver->GetTimingsLogger()->AddLogger(cu.timings);
782  return result;
783}
784
785CompiledMethod* QuickCompiler::JniCompile(uint32_t access_flags,
786                                          uint32_t method_idx,
787                                          const DexFile& dex_file) const {
788  return ArtQuickJniCompileMethod(GetCompilerDriver(), access_flags, method_idx, dex_file);
789}
790
791uintptr_t QuickCompiler::GetEntryPointOf(mirror::ArtMethod* method) const {
792  return reinterpret_cast<uintptr_t>(method->GetEntryPointFromQuickCompiledCodePtrSize(
793      InstructionSetPointerSize(GetCompilerDriver()->GetInstructionSet())));
794}
795
796Mir2Lir* QuickCompiler::GetCodeGenerator(CompilationUnit* cu, void* compilation_unit) {
797  UNUSED(compilation_unit);
798  Mir2Lir* mir_to_lir = nullptr;
799  switch (cu->instruction_set) {
800    case kThumb2:
801      mir_to_lir = ArmCodeGenerator(cu, cu->mir_graph.get(), &cu->arena);
802      break;
803    case kArm64:
804      mir_to_lir = Arm64CodeGenerator(cu, cu->mir_graph.get(), &cu->arena);
805      break;
806    case kMips:
807      // Fall-through.
808    case kMips64:
809      mir_to_lir = MipsCodeGenerator(cu, cu->mir_graph.get(), &cu->arena);
810      break;
811    case kX86:
812      // Fall-through.
813    case kX86_64:
814      mir_to_lir = X86CodeGenerator(cu, cu->mir_graph.get(), &cu->arena);
815      break;
816    default:
817      LOG(FATAL) << "Unexpected instruction set: " << cu->instruction_set;
818  }
819
820  /* The number of compiler temporaries depends on backend so set it up now if possible */
821  if (mir_to_lir) {
822    size_t max_temps = mir_to_lir->GetMaxPossibleCompilerTemps();
823    bool set_max = cu->mir_graph->SetMaxAvailableNonSpecialCompilerTemps(max_temps);
824    CHECK(set_max);
825  }
826  return mir_to_lir;
827}
828
829QuickCompiler::QuickCompiler(CompilerDriver* driver) : Compiler(driver, 100) {
830  const auto& compiler_options = driver->GetCompilerOptions();
831  auto* pass_manager_options = compiler_options.GetPassManagerOptions();
832  pre_opt_pass_manager_.reset(new PassManager(*pass_manager_options));
833  CHECK(pre_opt_pass_manager_.get() != nullptr);
834  PassDriverMEOpts::SetupPasses(pre_opt_pass_manager_.get());
835  pre_opt_pass_manager_->CreateDefaultPassList();
836  if (pass_manager_options->GetPrintPassOptions()) {
837    PassDriverMEOpts::PrintPassOptions(pre_opt_pass_manager_.get());
838  }
839  // TODO: Different options for pre vs post opts?
840  post_opt_pass_manager_.reset(new PassManager(PassManagerOptions()));
841  CHECK(post_opt_pass_manager_.get() != nullptr);
842  PassDriverMEPostOpt::SetupPasses(post_opt_pass_manager_.get());
843  post_opt_pass_manager_->CreateDefaultPassList();
844  if (pass_manager_options->GetPrintPassOptions()) {
845    PassDriverMEPostOpt::PrintPassOptions(post_opt_pass_manager_.get());
846  }
847}
848
849QuickCompiler::~QuickCompiler() {
850}
851
852Compiler* CreateQuickCompiler(CompilerDriver* driver) {
853  return QuickCompiler::Create(driver);
854}
855
856Compiler* QuickCompiler::Create(CompilerDriver* driver) {
857  return new QuickCompiler(driver);
858}
859
860}  // namespace art
861