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 #ifndef ART_COMPILER_OPTIMIZING_STACK_MAP_STREAM_H_ 18 #define ART_COMPILER_OPTIMIZING_STACK_MAP_STREAM_H_ 19 20 #include "base/allocator.h" 21 #include "base/arena_bit_vector.h" 22 #include "base/bit_table.h" 23 #include "base/bit_vector-inl.h" 24 #include "base/macros.h" 25 #include "base/memory_region.h" 26 #include "base/scoped_arena_containers.h" 27 #include "base/value_object.h" 28 #include "dex_register_location.h" 29 #include "nodes.h" 30 #include "oat/stack_map.h" 31 32 namespace art HIDDEN { 33 34 class CodeGenerator; 35 36 /** 37 * Collects and builds stack maps for a method. All the stack maps 38 * for a method are placed in a CodeInfo object. 39 */ 40 class StackMapStream : public DeletableArenaObject<kArenaAllocStackMapStream> { 41 public: StackMapStream(ScopedArenaAllocator * allocator,InstructionSet instruction_set)42 explicit StackMapStream(ScopedArenaAllocator* allocator, InstructionSet instruction_set) 43 : allocator_(allocator), 44 instruction_set_(instruction_set), 45 stack_maps_(allocator), 46 register_masks_(allocator), 47 stack_masks_(allocator), 48 inline_infos_(allocator), 49 method_infos_(allocator), 50 dex_register_masks_(allocator), 51 dex_register_maps_(allocator), 52 dex_register_catalog_(allocator), 53 lazy_stack_masks_(allocator->Adapter(kArenaAllocStackMapStream)), 54 current_stack_map_(), 55 current_inline_infos_(allocator->Adapter(kArenaAllocStackMapStream)), 56 current_dex_registers_(allocator->Adapter(kArenaAllocStackMapStream)), 57 previous_dex_registers_(allocator->Adapter(kArenaAllocStackMapStream)), 58 dex_register_timestamp_(allocator->Adapter(kArenaAllocStackMapStream)), 59 expected_num_dex_registers_(0u), 60 temp_dex_register_mask_(allocator, 32, true, kArenaAllocStackMapStream), 61 temp_dex_register_map_(allocator->Adapter(kArenaAllocStackMapStream)) { 62 } 63 64 void BeginMethod(size_t frame_size_in_bytes, 65 size_t core_spill_mask, 66 size_t fp_spill_mask, 67 uint32_t num_dex_registers, 68 bool baseline, 69 bool debuggable, 70 bool has_should_deoptimize_flag = false); 71 void EndMethod(size_t code_size); 72 73 void BeginStackMapEntry( 74 uint32_t dex_pc, 75 uint32_t native_pc_offset, 76 uint32_t register_mask = 0, 77 BitVector* sp_mask = nullptr, 78 StackMap::Kind kind = StackMap::Kind::Default, 79 bool needs_vreg_info = true, 80 const std::vector<uint32_t>& dex_pc_list_for_catch_verification = std::vector<uint32_t>()); 81 82 void EndStackMapEntry(); 83 AddDexRegisterEntry(DexRegisterLocation::Kind kind,int32_t value)84 void AddDexRegisterEntry(DexRegisterLocation::Kind kind, int32_t value) { 85 current_dex_registers_.push_back(DexRegisterLocation(kind, value)); 86 } 87 88 void BeginInlineInfoEntry(ArtMethod* method, 89 uint32_t dex_pc, 90 uint32_t num_dex_registers, 91 const DexFile* outer_dex_file = nullptr, 92 const CodeGenerator* codegen = nullptr); 93 void EndInlineInfoEntry(); 94 GetNumberOfStackMaps()95 size_t GetNumberOfStackMaps() const { 96 return stack_maps_.size(); 97 } 98 99 uint32_t GetStackMapNativePcOffset(size_t i); 100 void SetStackMapNativePcOffset(size_t i, uint32_t native_pc_offset); 101 102 // Encode all stack map data. 103 // The returned vector is allocated using the allocator passed to the StackMapStream. 104 ScopedArenaVector<uint8_t> Encode(); 105 106 private: 107 static constexpr uint32_t kNoValue = -1; 108 109 void CreateDexRegisterMap(); 110 111 // Invokes the callback with pointer of each BitTableBuilder field. 112 template<typename Callback> ForEachBitTable(Callback && callback)113 void ForEachBitTable(Callback&& callback) { 114 size_t index = 0; 115 callback(index++, &stack_maps_); 116 callback(index++, ®ister_masks_); 117 callback(index++, &stack_masks_); 118 callback(index++, &inline_infos_); 119 callback(index++, &method_infos_); 120 callback(index++, &dex_register_masks_); 121 callback(index++, &dex_register_maps_); 122 callback(index++, &dex_register_catalog_); 123 CHECK_EQ(index, CodeInfo::kNumBitTables); 124 } 125 126 ScopedArenaAllocator* allocator_; 127 const InstructionSet instruction_set_; 128 uint32_t code_size_ = 0; 129 uint32_t packed_frame_size_ = 0; 130 uint32_t core_spill_mask_ = 0; 131 uint32_t fp_spill_mask_ = 0; 132 uint32_t num_dex_registers_ = 0; 133 bool baseline_ = false; 134 bool debuggable_ = false; 135 bool has_should_deoptimize_flag_ = false; 136 BitTableBuilder<StackMap> stack_maps_; 137 BitTableBuilder<RegisterMask> register_masks_; 138 BitmapTableBuilder stack_masks_; 139 BitTableBuilder<InlineInfo> inline_infos_; 140 BitTableBuilder<MethodInfo> method_infos_; 141 BitmapTableBuilder dex_register_masks_; 142 BitTableBuilder<DexRegisterMapInfo> dex_register_maps_; 143 BitTableBuilder<DexRegisterInfo> dex_register_catalog_; 144 145 ScopedArenaVector<BitVector*> lazy_stack_masks_; 146 147 // Variables which track the current state between Begin/End calls; 148 bool in_method_ = false; 149 bool in_stack_map_ = false; 150 bool in_inline_info_ = false; 151 BitTableBuilder<StackMap>::Entry current_stack_map_; 152 ScopedArenaVector<BitTableBuilder<InlineInfo>::Entry> current_inline_infos_; 153 ScopedArenaVector<DexRegisterLocation> current_dex_registers_; 154 ScopedArenaVector<DexRegisterLocation> previous_dex_registers_; 155 ScopedArenaVector<uint32_t> dex_register_timestamp_; // Stack map index of last change. 156 size_t expected_num_dex_registers_; 157 158 // Temporary variables used in CreateDexRegisterMap. 159 // They are here so that we can reuse the reserved memory. 160 ArenaBitVector temp_dex_register_mask_; 161 ScopedArenaVector<BitTableBuilder<DexRegisterMapInfo>::Entry> temp_dex_register_map_; 162 163 // A set of lambda functions to be executed at the end to verify 164 // the encoded data. It is generally only used in debug builds. 165 std::vector<std::function<void(CodeInfo&)>> dchecks_; 166 167 DISALLOW_COPY_AND_ASSIGN(StackMapStream); 168 }; 169 170 } // namespace art 171 172 #endif // ART_COMPILER_OPTIMIZING_STACK_MAP_STREAM_H_ 173