1 /* 2 * Copyright (C) 2015 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_REFERENCE_TYPE_PROPAGATION_H_ 18 #define ART_COMPILER_OPTIMIZING_REFERENCE_TYPE_PROPAGATION_H_ 19 20 #include "base/arena_containers.h" 21 #include "mirror/class-inl.h" 22 #include "nodes.h" 23 #include "obj_ptr.h" 24 #include "optimization.h" 25 26 namespace art { 27 28 /** 29 * Propagates reference types to instructions. 30 */ 31 class ReferenceTypePropagation : public HOptimization { 32 public: 33 ReferenceTypePropagation(HGraph* graph, 34 Handle<mirror::ClassLoader> class_loader, 35 Handle<mirror::DexCache> hint_dex_cache, 36 VariableSizedHandleScope* handles, 37 bool is_first_run, 38 const char* name = kReferenceTypePropagationPassName); 39 40 // Visit a single instruction. 41 void Visit(HInstruction* instruction); 42 43 bool Run() override; 44 45 // Returns true if klass is admissible to the propagation: non-null and resolved. 46 // For an array type, we also check if the component type is admissible. IsAdmissible(ObjPtr<mirror::Class> klass)47 static bool IsAdmissible(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) { 48 return klass != nullptr && 49 klass->IsResolved() && 50 (!klass->IsArrayClass() || IsAdmissible(klass->GetComponentType())); 51 } 52 53 static constexpr const char* kReferenceTypePropagationPassName = "reference_type_propagation"; 54 55 // Fix the reference type for an instruction whose inputs have changed. 56 // For a select instruction, the reference types of the inputs are merged 57 // and the resulting reference type is set on the select instruction. 58 static void FixUpInstructionType(HInstruction* instruction, 59 VariableSizedHandleScope* handle_scope); 60 61 private: 62 class HandleCache { 63 public: HandleCache(VariableSizedHandleScope * handles)64 explicit HandleCache(VariableSizedHandleScope* handles) : handles_(handles) { } 65 66 template <typename T> NewHandle(T * object)67 MutableHandle<T> NewHandle(T* object) REQUIRES_SHARED(Locks::mutator_lock_) { 68 return handles_->NewHandle(object); 69 } 70 71 template <typename T> NewHandle(ObjPtr<T> object)72 MutableHandle<T> NewHandle(ObjPtr<T> object) REQUIRES_SHARED(Locks::mutator_lock_) { 73 return handles_->NewHandle(object); 74 } 75 76 ReferenceTypeInfo::TypeHandle GetObjectClassHandle(); 77 ReferenceTypeInfo::TypeHandle GetClassClassHandle(); 78 ReferenceTypeInfo::TypeHandle GetMethodHandleClassHandle(); 79 ReferenceTypeInfo::TypeHandle GetMethodTypeClassHandle(); 80 ReferenceTypeInfo::TypeHandle GetStringClassHandle(); 81 ReferenceTypeInfo::TypeHandle GetThrowableClassHandle(); 82 83 private: 84 VariableSizedHandleScope* handles_; 85 86 ReferenceTypeInfo::TypeHandle object_class_handle_; 87 ReferenceTypeInfo::TypeHandle class_class_handle_; 88 ReferenceTypeInfo::TypeHandle method_handle_class_handle_; 89 ReferenceTypeInfo::TypeHandle method_type_class_handle_; 90 ReferenceTypeInfo::TypeHandle string_class_handle_; 91 ReferenceTypeInfo::TypeHandle throwable_class_handle_; 92 }; 93 94 class RTPVisitor; 95 96 static ReferenceTypeInfo MergeTypes(const ReferenceTypeInfo& a, 97 const ReferenceTypeInfo& b, 98 HandleCache* handle_cache) 99 REQUIRES_SHARED(Locks::mutator_lock_); 100 101 void ValidateTypes(); 102 103 Handle<mirror::ClassLoader> class_loader_; 104 105 // Note: hint_dex_cache_ is usually, but not necessarily, the dex cache associated with 106 // graph_->GetDexFile(). Since we may look up also in other dex files, it's used only 107 // as a hint, to reduce the number of calls to the costly ClassLinker::FindDexCache(). 108 Handle<mirror::DexCache> hint_dex_cache_; 109 HandleCache handle_cache_; 110 111 // Whether this reference type propagation is the first run we are doing. 112 const bool is_first_run_; 113 114 friend class ReferenceTypePropagationTest; 115 116 DISALLOW_COPY_AND_ASSIGN(ReferenceTypePropagation); 117 }; 118 119 } // namespace art 120 121 #endif // ART_COMPILER_OPTIMIZING_REFERENCE_TYPE_PROPAGATION_H_ 122