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:
StackMapStream(ScopedArenaAllocator * allocator,InstructionSet instruction_set)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 
AddDexRegisterEntry(DexRegisterLocation::Kind kind,int32_t value)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 
GetNumberOfStackMaps()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