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 <fstream> 18 #include <stdint.h> 19 20 #include "builder.h" 21 #include "code_generator.h" 22 #include "compilers.h" 23 #include "driver/compiler_driver.h" 24 #include "driver/dex_compilation_unit.h" 25 #include "graph_visualizer.h" 26 #include "nodes.h" 27 #include "register_allocator.h" 28 #include "ssa_phi_elimination.h" 29 #include "ssa_liveness_analysis.h" 30 #include "utils/arena_allocator.h" 31 32 namespace art { 33 34 /** 35 * Used by the code generator, to allocate the code in a vector. 36 */ 37 class CodeVectorAllocator FINAL : public CodeAllocator { 38 public: 39 CodeVectorAllocator() { } 40 41 virtual uint8_t* Allocate(size_t size) { 42 size_ = size; 43 memory_.resize(size); 44 return &memory_[0]; 45 } 46 47 size_t GetSize() const { return size_; } 48 const std::vector<uint8_t>& GetMemory() const { return memory_; } 49 50 private: 51 std::vector<uint8_t> memory_; 52 size_t size_; 53 54 DISALLOW_COPY_AND_ASSIGN(CodeVectorAllocator); 55 }; 56 57 /** 58 * If set to true, generates a file suitable for the c1visualizer tool and IRHydra. 59 */ 60 static bool kIsVisualizerEnabled = false; 61 62 /** 63 * Filter to apply to the visualizer. Methods whose name contain that filter will 64 * be in the file. 65 */ 66 static const char* kStringFilter = ""; 67 68 OptimizingCompiler::OptimizingCompiler(CompilerDriver* driver) : QuickCompiler(driver) { 69 if (kIsVisualizerEnabled) { 70 visualizer_output_.reset(new std::ofstream("art.cfg")); 71 } 72 } 73 74 CompiledMethod* OptimizingCompiler::TryCompile(const DexFile::CodeItem* code_item, 75 uint32_t access_flags, 76 InvokeType invoke_type, 77 uint16_t class_def_idx, 78 uint32_t method_idx, 79 jobject class_loader, 80 const DexFile& dex_file) const { 81 InstructionSet instruction_set = GetCompilerDriver()->GetInstructionSet(); 82 // Always use the thumb2 assembler: some runtime functionality (like implicit stack 83 // overflow checks) assume thumb2. 84 if (instruction_set == kArm) { 85 instruction_set = kThumb2; 86 } 87 88 // Do not attempt to compile on architectures we do not support. 89 if (instruction_set != kX86 && instruction_set != kX86_64 && instruction_set != kThumb2) { 90 return nullptr; 91 } 92 93 DexCompilationUnit dex_compilation_unit( 94 nullptr, class_loader, art::Runtime::Current()->GetClassLinker(), dex_file, code_item, 95 class_def_idx, method_idx, access_flags, 96 GetCompilerDriver()->GetVerifiedMethod(&dex_file, method_idx)); 97 98 // For testing purposes, we put a special marker on method names that should be compiled 99 // with this compiler. This makes sure we're not regressing. 100 bool shouldCompile = dex_compilation_unit.GetSymbol().find("00024opt_00024") != std::string::npos; 101 bool shouldOptimize = 102 dex_compilation_unit.GetSymbol().find("00024reg_00024") != std::string::npos; 103 104 ArenaPool pool; 105 ArenaAllocator arena(&pool); 106 HGraphBuilder builder(&arena, &dex_compilation_unit, &dex_file, GetCompilerDriver()); 107 108 HGraph* graph = builder.BuildGraph(*code_item); 109 if (graph == nullptr) { 110 if (shouldCompile) { 111 LOG(FATAL) << "Could not build graph in optimizing compiler"; 112 } 113 return nullptr; 114 } 115 116 CodeGenerator* codegen = CodeGenerator::Create(&arena, graph, instruction_set); 117 if (codegen == nullptr) { 118 if (shouldCompile) { 119 LOG(FATAL) << "Could not find code generator for optimizing compiler"; 120 } 121 return nullptr; 122 } 123 124 HGraphVisualizer visualizer( 125 visualizer_output_.get(), graph, kStringFilter, *codegen, dex_compilation_unit); 126 visualizer.DumpGraph("builder"); 127 128 CodeVectorAllocator allocator; 129 130 if (RegisterAllocator::CanAllocateRegistersFor(*graph, instruction_set)) { 131 graph->BuildDominatorTree(); 132 graph->TransformToSSA(); 133 visualizer.DumpGraph("ssa"); 134 graph->FindNaturalLoops(); 135 136 SsaRedundantPhiElimination(graph).Run(); 137 SsaDeadPhiElimination(graph).Run(); 138 139 SsaLivenessAnalysis liveness(*graph, codegen); 140 liveness.Analyze(); 141 visualizer.DumpGraph(kLivenessPassName); 142 143 RegisterAllocator register_allocator(graph->GetArena(), codegen, liveness); 144 register_allocator.AllocateRegisters(); 145 146 visualizer.DumpGraph(kRegisterAllocatorPassName); 147 codegen->CompileOptimized(&allocator); 148 } else if (shouldOptimize && RegisterAllocator::Supports(instruction_set)) { 149 LOG(FATAL) << "Could not allocate registers in optimizing compiler"; 150 } else { 151 codegen->CompileBaseline(&allocator); 152 153 // Run these phases to get some test coverage. 154 graph->BuildDominatorTree(); 155 graph->TransformToSSA(); 156 visualizer.DumpGraph("ssa"); 157 graph->FindNaturalLoops(); 158 SsaLivenessAnalysis liveness(*graph, codegen); 159 liveness.Analyze(); 160 visualizer.DumpGraph(kLivenessPassName); 161 } 162 163 std::vector<uint8_t> mapping_table; 164 codegen->BuildMappingTable(&mapping_table); 165 std::vector<uint8_t> vmap_table; 166 codegen->BuildVMapTable(&vmap_table); 167 std::vector<uint8_t> gc_map; 168 codegen->BuildNativeGCMap(&gc_map, dex_compilation_unit); 169 170 return new CompiledMethod(GetCompilerDriver(), 171 instruction_set, 172 allocator.GetMemory(), 173 codegen->GetFrameSize(), 174 codegen->GetCoreSpillMask(), 175 0, /* FPR spill mask, unused */ 176 mapping_table, 177 vmap_table, 178 gc_map, 179 nullptr); 180 } 181 182 } // namespace art 183
