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