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