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