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 "optimization.h"
18 
19 #ifdef ART_ENABLE_CODEGEN_arm
20 #include "critical_native_abi_fixup_arm.h"
21 #include "instruction_simplifier_arm.h"
22 #endif
23 #ifdef ART_ENABLE_CODEGEN_arm64
24 #include "instruction_simplifier_arm64.h"
25 #endif
26 #ifdef ART_ENABLE_CODEGEN_x86
27 #include "pc_relative_fixups_x86.h"
28 #include "instruction_simplifier_x86.h"
29 #endif
30 #if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
31 #include "x86_memory_gen.h"
32 #endif
33 #ifdef ART_ENABLE_CODEGEN_x86_64
34 #include "instruction_simplifier_x86_64.h"
35 #endif
36 
37 #include "bounds_check_elimination.h"
38 #include "cha_guard_optimization.h"
39 #include "code_sinking.h"
40 #include "constant_folding.h"
41 #include "constructor_fence_redundancy_elimination.h"
42 #include "dead_code_elimination.h"
43 #include "dex/code_item_accessors-inl.h"
44 #include "driver/compiler_options.h"
45 #include "driver/dex_compilation_unit.h"
46 #include "gvn.h"
47 #include "induction_var_analysis.h"
48 #include "inliner.h"
49 #include "instruction_simplifier.h"
50 #include "intrinsics.h"
51 #include "licm.h"
52 #include "load_store_elimination.h"
53 #include "loop_optimization.h"
54 #include "scheduler.h"
55 #include "select_generator.h"
56 #include "sharpening.h"
57 #include "side_effects_analysis.h"
58 
59 // Decide between default or alternative pass name.
60 
61 namespace art {
62 
OptimizationPassName(OptimizationPass pass)63 const char* OptimizationPassName(OptimizationPass pass) {
64   switch (pass) {
65     case OptimizationPass::kSideEffectsAnalysis:
66       return SideEffectsAnalysis::kSideEffectsAnalysisPassName;
67     case OptimizationPass::kInductionVarAnalysis:
68       return HInductionVarAnalysis::kInductionPassName;
69     case OptimizationPass::kGlobalValueNumbering:
70       return GVNOptimization::kGlobalValueNumberingPassName;
71     case OptimizationPass::kInvariantCodeMotion:
72       return LICM::kLoopInvariantCodeMotionPassName;
73     case OptimizationPass::kLoopOptimization:
74       return HLoopOptimization::kLoopOptimizationPassName;
75     case OptimizationPass::kBoundsCheckElimination:
76       return BoundsCheckElimination::kBoundsCheckEliminationPassName;
77     case OptimizationPass::kLoadStoreElimination:
78       return LoadStoreElimination::kLoadStoreEliminationPassName;
79     case OptimizationPass::kConstantFolding:
80       return HConstantFolding::kConstantFoldingPassName;
81     case OptimizationPass::kDeadCodeElimination:
82       return HDeadCodeElimination::kDeadCodeEliminationPassName;
83     case OptimizationPass::kInliner:
84       return HInliner::kInlinerPassName;
85     case OptimizationPass::kSelectGenerator:
86       return HSelectGenerator::kSelectGeneratorPassName;
87     case OptimizationPass::kAggressiveInstructionSimplifier:
88     case OptimizationPass::kInstructionSimplifier:
89       return InstructionSimplifier::kInstructionSimplifierPassName;
90     case OptimizationPass::kCHAGuardOptimization:
91       return CHAGuardOptimization::kCHAGuardOptimizationPassName;
92     case OptimizationPass::kCodeSinking:
93       return CodeSinking::kCodeSinkingPassName;
94     case OptimizationPass::kConstructorFenceRedundancyElimination:
95       return ConstructorFenceRedundancyElimination::kCFREPassName;
96     case OptimizationPass::kScheduling:
97       return HInstructionScheduling::kInstructionSchedulingPassName;
98 #ifdef ART_ENABLE_CODEGEN_arm
99     case OptimizationPass::kInstructionSimplifierArm:
100       return arm::InstructionSimplifierArm::kInstructionSimplifierArmPassName;
101     case OptimizationPass::kCriticalNativeAbiFixupArm:
102       return arm::CriticalNativeAbiFixupArm::kCriticalNativeAbiFixupArmPassName;
103 #endif
104 #ifdef ART_ENABLE_CODEGEN_arm64
105     case OptimizationPass::kInstructionSimplifierArm64:
106       return arm64::InstructionSimplifierArm64::kInstructionSimplifierArm64PassName;
107 #endif
108 #ifdef ART_ENABLE_CODEGEN_x86
109     case OptimizationPass::kPcRelativeFixupsX86:
110       return x86::PcRelativeFixups::kPcRelativeFixupsX86PassName;
111     case OptimizationPass::kInstructionSimplifierX86:
112       return x86::InstructionSimplifierX86::kInstructionSimplifierX86PassName;
113 #endif
114 #ifdef ART_ENABLE_CODEGEN_x86_64
115     case OptimizationPass::kInstructionSimplifierX86_64:
116       return x86_64::InstructionSimplifierX86_64::kInstructionSimplifierX86_64PassName;
117 #endif
118 #if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
119     case OptimizationPass::kX86MemoryOperandGeneration:
120       return x86::X86MemoryOperandGeneration::kX86MemoryOperandGenerationPassName;
121 #endif
122     case OptimizationPass::kNone:
123       LOG(FATAL) << "kNone does not represent an actual pass";
124       UNREACHABLE();
125   }
126 }
127 
128 #define X(x) if (pass_name == OptimizationPassName((x))) return (x)
129 
OptimizationPassByName(const std::string & pass_name)130 OptimizationPass OptimizationPassByName(const std::string& pass_name) {
131   X(OptimizationPass::kBoundsCheckElimination);
132   X(OptimizationPass::kCHAGuardOptimization);
133   X(OptimizationPass::kCodeSinking);
134   X(OptimizationPass::kConstantFolding);
135   X(OptimizationPass::kConstructorFenceRedundancyElimination);
136   X(OptimizationPass::kDeadCodeElimination);
137   X(OptimizationPass::kGlobalValueNumbering);
138   X(OptimizationPass::kInductionVarAnalysis);
139   X(OptimizationPass::kInliner);
140   X(OptimizationPass::kInstructionSimplifier);
141   X(OptimizationPass::kInvariantCodeMotion);
142   X(OptimizationPass::kLoadStoreElimination);
143   X(OptimizationPass::kLoopOptimization);
144   X(OptimizationPass::kScheduling);
145   X(OptimizationPass::kSelectGenerator);
146   X(OptimizationPass::kSideEffectsAnalysis);
147 #ifdef ART_ENABLE_CODEGEN_arm
148   X(OptimizationPass::kInstructionSimplifierArm);
149   X(OptimizationPass::kCriticalNativeAbiFixupArm);
150 #endif
151 #ifdef ART_ENABLE_CODEGEN_arm64
152   X(OptimizationPass::kInstructionSimplifierArm64);
153 #endif
154 #ifdef ART_ENABLE_CODEGEN_x86
155   X(OptimizationPass::kPcRelativeFixupsX86);
156   X(OptimizationPass::kX86MemoryOperandGeneration);
157 #endif
158   LOG(FATAL) << "Cannot find optimization " << pass_name;
159   UNREACHABLE();
160 }
161 
162 #undef X
163 
ConstructOptimizations(const OptimizationDef definitions[],size_t length,ArenaAllocator * allocator,HGraph * graph,OptimizingCompilerStats * stats,CodeGenerator * codegen,const DexCompilationUnit & dex_compilation_unit)164 ArenaVector<HOptimization*> ConstructOptimizations(
165     const OptimizationDef definitions[],
166     size_t length,
167     ArenaAllocator* allocator,
168     HGraph* graph,
169     OptimizingCompilerStats* stats,
170     CodeGenerator* codegen,
171     const DexCompilationUnit& dex_compilation_unit) {
172   ArenaVector<HOptimization*> optimizations(allocator->Adapter());
173 
174   // Some optimizations require SideEffectsAnalysis or HInductionVarAnalysis
175   // instances. This method uses the nearest instance preceeding it in the pass
176   // name list or fails fatally if no such analysis can be found.
177   SideEffectsAnalysis* most_recent_side_effects = nullptr;
178   HInductionVarAnalysis* most_recent_induction = nullptr;
179 
180   // Loop over the requested optimizations.
181   for (size_t i = 0; i < length; i++) {
182     OptimizationPass pass = definitions[i].pass;
183     const char* alt_name = definitions[i].pass_name;
184     const char* pass_name = alt_name != nullptr
185         ? alt_name
186         : OptimizationPassName(pass);
187     HOptimization* opt = nullptr;
188 
189     switch (pass) {
190       //
191       // Analysis passes (kept in most recent for subsequent passes).
192       //
193       case OptimizationPass::kSideEffectsAnalysis:
194         opt = most_recent_side_effects = new (allocator) SideEffectsAnalysis(graph, pass_name);
195         break;
196       case OptimizationPass::kInductionVarAnalysis:
197         opt = most_recent_induction = new (allocator) HInductionVarAnalysis(graph, pass_name);
198         break;
199       //
200       // Passes that need prior analysis.
201       //
202       case OptimizationPass::kGlobalValueNumbering:
203         CHECK(most_recent_side_effects != nullptr);
204         opt = new (allocator) GVNOptimization(graph, *most_recent_side_effects, pass_name);
205         break;
206       case OptimizationPass::kInvariantCodeMotion:
207         CHECK(most_recent_side_effects != nullptr);
208         opt = new (allocator) LICM(graph, *most_recent_side_effects, stats, pass_name);
209         break;
210       case OptimizationPass::kLoopOptimization:
211         CHECK(most_recent_induction != nullptr);
212         opt = new (allocator) HLoopOptimization(
213             graph, *codegen, most_recent_induction, stats, pass_name);
214         break;
215       case OptimizationPass::kBoundsCheckElimination:
216         CHECK(most_recent_side_effects != nullptr && most_recent_induction != nullptr);
217         opt = new (allocator) BoundsCheckElimination(
218             graph, *most_recent_side_effects, most_recent_induction, pass_name);
219         break;
220       //
221       // Regular passes.
222       //
223       case OptimizationPass::kConstantFolding:
224         opt = new (allocator) HConstantFolding(graph, pass_name);
225         break;
226       case OptimizationPass::kDeadCodeElimination:
227         opt = new (allocator) HDeadCodeElimination(graph, stats, pass_name);
228         break;
229       case OptimizationPass::kInliner: {
230         CodeItemDataAccessor accessor(*dex_compilation_unit.GetDexFile(),
231                                       dex_compilation_unit.GetCodeItem());
232         opt = new (allocator) HInliner(graph,                   // outer_graph
233                                        graph,                   // outermost_graph
234                                        codegen,
235                                        dex_compilation_unit,    // outer_compilation_unit
236                                        dex_compilation_unit,    // outermost_compilation_unit
237                                        stats,
238                                        accessor.RegistersSize(),
239                                        /* total_number_of_instructions= */ 0,
240                                        /* parent= */ nullptr,
241                                        /* depth= */ 0,
242                                        pass_name);
243         break;
244       }
245       case OptimizationPass::kSelectGenerator:
246         opt = new (allocator) HSelectGenerator(graph, stats, pass_name);
247         break;
248       case OptimizationPass::kInstructionSimplifier:
249         opt = new (allocator) InstructionSimplifier(graph, codegen, stats, pass_name);
250         break;
251       case OptimizationPass::kAggressiveInstructionSimplifier:
252         opt = new (allocator) InstructionSimplifier(graph,
253                                                     codegen,
254                                                     stats,
255                                                     pass_name,
256                                                     /* use_all_optimizations_ = */ true);
257         break;
258       case OptimizationPass::kCHAGuardOptimization:
259         opt = new (allocator) CHAGuardOptimization(graph, pass_name);
260         break;
261       case OptimizationPass::kCodeSinking:
262         opt = new (allocator) CodeSinking(graph, stats, pass_name);
263         break;
264       case OptimizationPass::kConstructorFenceRedundancyElimination:
265         opt = new (allocator) ConstructorFenceRedundancyElimination(graph, stats, pass_name);
266         break;
267       case OptimizationPass::kLoadStoreElimination:
268         opt = new (allocator) LoadStoreElimination(graph, stats, pass_name);
269         break;
270       case OptimizationPass::kScheduling:
271         opt = new (allocator) HInstructionScheduling(
272             graph, codegen->GetCompilerOptions().GetInstructionSet(), codegen, pass_name);
273         break;
274       //
275       // Arch-specific passes.
276       //
277 #ifdef ART_ENABLE_CODEGEN_arm
278       case OptimizationPass::kInstructionSimplifierArm:
279         DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
280         opt = new (allocator) arm::InstructionSimplifierArm(graph, stats);
281         break;
282       case OptimizationPass::kCriticalNativeAbiFixupArm:
283         DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
284         opt = new (allocator) arm::CriticalNativeAbiFixupArm(graph, stats);
285         break;
286 #endif
287 #ifdef ART_ENABLE_CODEGEN_arm64
288       case OptimizationPass::kInstructionSimplifierArm64:
289         DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
290         opt = new (allocator) arm64::InstructionSimplifierArm64(graph, stats);
291         break;
292 #endif
293 #ifdef ART_ENABLE_CODEGEN_x86
294       case OptimizationPass::kPcRelativeFixupsX86:
295         DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
296         opt = new (allocator) x86::PcRelativeFixups(graph, codegen, stats);
297         break;
298       case OptimizationPass::kX86MemoryOperandGeneration:
299         DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
300         opt = new (allocator) x86::X86MemoryOperandGeneration(graph, codegen, stats);
301         break;
302       case OptimizationPass::kInstructionSimplifierX86:
303        opt = new (allocator) x86::InstructionSimplifierX86(graph, codegen, stats);
304        break;
305 #endif
306 #ifdef ART_ENABLE_CODEGEN_x86_64
307       case OptimizationPass::kInstructionSimplifierX86_64:
308         opt = new (allocator) x86_64::InstructionSimplifierX86_64(graph, codegen, stats);
309         break;
310 #endif
311       case OptimizationPass::kNone:
312         LOG(FATAL) << "kNone does not represent an actual pass";
313         UNREACHABLE();
314     }  // switch
315 
316     // Add each next optimization to result vector.
317     CHECK(opt != nullptr);
318     DCHECK_STREQ(pass_name, opt->GetPassName());  // Consistency check.
319     optimizations.push_back(opt);
320   }
321 
322   return optimizations;
323 }
324 
325 }  // namespace art
326