Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 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 | */ |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 16 | |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 17 | #include "stack_map_stream.h" |
| 18 | |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 19 | #include <memory> |
| 20 | |
Andreas Gampe | 90b936d | 2017-01-31 08:58:55 -0800 | [diff] [blame] | 21 | #include "art_method-inl.h" |
David Srbecky | 45aa598 | 2016-03-18 02:15:09 +0000 | [diff] [blame] | 22 | #include "base/stl_util.h" |
David Sehr | 9e734c7 | 2018-01-04 17:56:19 -0800 | [diff] [blame] | 23 | #include "dex/dex_file_types.h" |
Nicolas Geoffray | fbdfa6d | 2017-02-03 10:43:13 +0000 | [diff] [blame] | 24 | #include "optimizing/optimizing_compiler.h" |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 25 | #include "runtime.h" |
| 26 | #include "scoped_thread_state_change-inl.h" |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 27 | #include "stack_map.h" |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 28 | |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 29 | namespace art { |
| 30 | |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 31 | constexpr static bool kVerifyStackMaps = kIsDebugBuild; |
| 32 | |
David Srbecky | d02b23f | 2018-05-29 23:27:22 +0100 | [diff] [blame] | 33 | uint32_t StackMapStream::GetStackMapNativePcOffset(size_t i) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 34 | return StackMap::UnpackNativePc(stack_maps_[i][StackMap::kPackedNativePc], instruction_set_); |
David Srbecky | d02b23f | 2018-05-29 23:27:22 +0100 | [diff] [blame] | 35 | } |
| 36 | |
| 37 | void StackMapStream::SetStackMapNativePcOffset(size_t i, uint32_t native_pc_offset) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 38 | stack_maps_[i][StackMap::kPackedNativePc] = |
| 39 | StackMap::PackNativePc(native_pc_offset, instruction_set_); |
David Srbecky | d02b23f | 2018-05-29 23:27:22 +0100 | [diff] [blame] | 40 | } |
| 41 | |
Calin Juravle | 4f46ac5 | 2015-04-23 18:47:21 +0100 | [diff] [blame] | 42 | void StackMapStream::BeginStackMapEntry(uint32_t dex_pc, |
| 43 | uint32_t native_pc_offset, |
| 44 | uint32_t register_mask, |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 45 | BitVector* stack_mask, |
Calin Juravle | 4f46ac5 | 2015-04-23 18:47:21 +0100 | [diff] [blame] | 46 | uint32_t num_dex_registers, |
David Srbecky | 50fac06 | 2018-06-13 18:55:35 +0100 | [diff] [blame] | 47 | uint8_t inlining_depth, |
| 48 | StackMap::Kind kind) { |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 49 | DCHECK(!in_stack_map_) << "Mismatched Begin/End calls"; |
| 50 | in_stack_map_ = true; |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 51 | // num_dex_registers_ is the constant per-method number of registers. |
| 52 | // However we initially don't know what the value is, so lazily initialize it. |
| 53 | if (num_dex_registers_ == 0) { |
| 54 | num_dex_registers_ = num_dex_registers; |
| 55 | } else if (num_dex_registers > 0) { |
| 56 | DCHECK_EQ(num_dex_registers_, num_dex_registers) << "Inconsistent register count"; |
| 57 | } |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 58 | |
David Srbecky | cf7833e | 2018-06-14 16:45:22 +0100 | [diff] [blame] | 59 | current_stack_map_ = BitTableBuilder<StackMap>::Entry(); |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 60 | current_stack_map_[StackMap::kKind] = static_cast<uint32_t>(kind); |
| 61 | current_stack_map_[StackMap::kPackedNativePc] = |
| 62 | StackMap::PackNativePc(native_pc_offset, instruction_set_); |
| 63 | current_stack_map_[StackMap::kDexPc] = dex_pc; |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 64 | if (register_mask != 0) { |
| 65 | uint32_t shift = LeastSignificantBit(register_mask); |
David Srbecky | cf7833e | 2018-06-14 16:45:22 +0100 | [diff] [blame] | 66 | BitTableBuilder<RegisterMask>::Entry entry; |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 67 | entry[RegisterMask::kValue] = register_mask >> shift; |
| 68 | entry[RegisterMask::kShift] = shift; |
| 69 | current_stack_map_[StackMap::kRegisterMaskIndex] = register_masks_.Dedup(&entry); |
Vladimir Marko | 174b2e2 | 2017-10-12 13:34:49 +0100 | [diff] [blame] | 70 | } |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 71 | // The compiler assumes the bit vector will be read during PrepareForFillIn(), |
| 72 | // and it might modify the data before that. Therefore, just store the pointer. |
| 73 | // See ClearSpillSlotsFromLoopPhisInStackMap in code_generator.h. |
| 74 | lazy_stack_masks_.push_back(stack_mask); |
David Srbecky | 6eb4d5e | 2018-06-03 12:00:20 +0100 | [diff] [blame] | 75 | current_inline_infos_.clear(); |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 76 | current_dex_registers_.clear(); |
| 77 | expected_num_dex_registers_ = num_dex_registers; |
| 78 | |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 79 | if (kVerifyStackMaps) { |
| 80 | size_t stack_map_index = stack_maps_.size(); |
| 81 | // Create lambda method, which will be executed at the very end to verify data. |
| 82 | // Parameters and local variables will be captured(stored) by the lambda "[=]". |
| 83 | dchecks_.emplace_back([=](const CodeInfo& code_info) { |
David Srbecky | 50fac06 | 2018-06-13 18:55:35 +0100 | [diff] [blame] | 84 | if (kind == StackMap::Kind::Default || kind == StackMap::Kind::OSR) { |
| 85 | StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, |
| 86 | instruction_set_); |
| 87 | CHECK_EQ(stack_map.Row(), stack_map_index); |
| 88 | } else if (kind == StackMap::Kind::Catch) { |
| 89 | StackMap stack_map = code_info.GetCatchStackMapForDexPc(dex_pc); |
| 90 | CHECK_EQ(stack_map.Row(), stack_map_index); |
| 91 | } |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 92 | StackMap stack_map = code_info.GetStackMapAt(stack_map_index); |
| 93 | CHECK_EQ(stack_map.GetNativePcOffset(instruction_set_), native_pc_offset); |
David Srbecky | 50fac06 | 2018-06-13 18:55:35 +0100 | [diff] [blame] | 94 | CHECK_EQ(stack_map.GetKind(), static_cast<uint32_t>(kind)); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 95 | CHECK_EQ(stack_map.GetDexPc(), dex_pc); |
| 96 | CHECK_EQ(code_info.GetRegisterMaskOf(stack_map), register_mask); |
| 97 | BitMemoryRegion seen_stack_mask = code_info.GetStackMaskOf(stack_map); |
| 98 | CHECK_GE(seen_stack_mask.size_in_bits(), stack_mask ? stack_mask->GetNumberOfBits() : 0); |
| 99 | for (size_t b = 0; b < seen_stack_mask.size_in_bits(); b++) { |
| 100 | CHECK_EQ(seen_stack_mask.LoadBit(b), stack_mask != nullptr && stack_mask->IsBitSet(b)); |
| 101 | } |
| 102 | CHECK_EQ(stack_map.HasInlineInfo(), (inlining_depth != 0)); |
David Srbecky | 6e69e52 | 2018-06-03 12:00:14 +0100 | [diff] [blame] | 103 | CHECK_EQ(code_info.GetInlineDepthOf(stack_map), inlining_depth); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 104 | }); |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 105 | } |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 106 | } |
| 107 | |
Calin Juravle | 4f46ac5 | 2015-04-23 18:47:21 +0100 | [diff] [blame] | 108 | void StackMapStream::EndStackMapEntry() { |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 109 | DCHECK(in_stack_map_) << "Mismatched Begin/End calls"; |
| 110 | in_stack_map_ = false; |
| 111 | DCHECK_EQ(expected_num_dex_registers_, current_dex_registers_.size()); |
| 112 | |
David Srbecky | 6eb4d5e | 2018-06-03 12:00:20 +0100 | [diff] [blame] | 113 | // Generate index into the InlineInfo table. |
| 114 | if (!current_inline_infos_.empty()) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 115 | current_inline_infos_.back()[InlineInfo::kIsLast] = InlineInfo::kLast; |
| 116 | current_stack_map_[StackMap::kInlineInfoIndex] = |
David Srbecky | 6eb4d5e | 2018-06-03 12:00:20 +0100 | [diff] [blame] | 117 | inline_infos_.Dedup(current_inline_infos_.data(), current_inline_infos_.size()); |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 118 | } |
| 119 | |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 120 | // Generate delta-compressed dex register map. |
| 121 | CreateDexRegisterMap(); |
| 122 | |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 123 | stack_maps_.Add(current_stack_map_); |
Calin Juravle | 4f46ac5 | 2015-04-23 18:47:21 +0100 | [diff] [blame] | 124 | } |
| 125 | |
Mathieu Chartier | d776ff0 | 2017-01-17 09:32:18 -0800 | [diff] [blame] | 126 | void StackMapStream::AddInvoke(InvokeType invoke_type, uint32_t dex_method_index) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 127 | uint32_t packed_native_pc = current_stack_map_[StackMap::kPackedNativePc]; |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 128 | size_t invoke_info_index = invoke_infos_.size(); |
David Srbecky | cf7833e | 2018-06-14 16:45:22 +0100 | [diff] [blame] | 129 | BitTableBuilder<InvokeInfo>::Entry entry; |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 130 | entry[InvokeInfo::kPackedNativePc] = packed_native_pc; |
| 131 | entry[InvokeInfo::kInvokeType] = invoke_type; |
| 132 | entry[InvokeInfo::kMethodInfoIndex] = method_infos_.Dedup({dex_method_index}); |
| 133 | invoke_infos_.Add(entry); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 134 | |
| 135 | if (kVerifyStackMaps) { |
| 136 | dchecks_.emplace_back([=](const CodeInfo& code_info) { |
| 137 | InvokeInfo invoke_info = code_info.GetInvokeInfo(invoke_info_index); |
| 138 | CHECK_EQ(invoke_info.GetNativePcOffset(instruction_set_), |
| 139 | StackMap::UnpackNativePc(packed_native_pc, instruction_set_)); |
| 140 | CHECK_EQ(invoke_info.GetInvokeType(), invoke_type); |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 141 | CHECK_EQ(method_infos_[invoke_info.GetMethodInfoIndex()][0], dex_method_index); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 142 | }); |
| 143 | } |
Mathieu Chartier | d776ff0 | 2017-01-17 09:32:18 -0800 | [diff] [blame] | 144 | } |
| 145 | |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 146 | void StackMapStream::BeginInlineInfoEntry(ArtMethod* method, |
Nicolas Geoffray | b1d0f3f | 2015-05-14 12:41:51 +0100 | [diff] [blame] | 147 | uint32_t dex_pc, |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 148 | uint32_t num_dex_registers, |
| 149 | const DexFile* outer_dex_file) { |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 150 | DCHECK(!in_inline_info_) << "Mismatched Begin/End calls"; |
| 151 | in_inline_info_ = true; |
| 152 | DCHECK_EQ(expected_num_dex_registers_, current_dex_registers_.size()); |
| 153 | |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 154 | expected_num_dex_registers_ += num_dex_registers; |
| 155 | |
David Srbecky | cf7833e | 2018-06-14 16:45:22 +0100 | [diff] [blame] | 156 | BitTableBuilder<InlineInfo>::Entry entry; |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 157 | entry[InlineInfo::kIsLast] = InlineInfo::kMore; |
| 158 | entry[InlineInfo::kDexPc] = dex_pc; |
| 159 | entry[InlineInfo::kNumberOfDexRegisters] = static_cast<uint32_t>(expected_num_dex_registers_); |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 160 | if (EncodeArtMethodInInlineInfo(method)) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 161 | entry[InlineInfo::kArtMethodHi] = High32Bits(reinterpret_cast<uintptr_t>(method)); |
| 162 | entry[InlineInfo::kArtMethodLo] = Low32Bits(reinterpret_cast<uintptr_t>(method)); |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 163 | } else { |
| 164 | if (dex_pc != static_cast<uint32_t>(-1) && kIsDebugBuild) { |
| 165 | ScopedObjectAccess soa(Thread::Current()); |
| 166 | DCHECK(IsSameDexFile(*outer_dex_file, *method->GetDexFile())); |
| 167 | } |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 168 | uint32_t dex_method_index = method->GetDexMethodIndexUnchecked(); |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 169 | entry[InlineInfo::kMethodInfoIndex] = method_infos_.Dedup({dex_method_index}); |
Nicolas Geoffray | 5d37c15 | 2017-01-12 13:25:19 +0000 | [diff] [blame] | 170 | } |
David Srbecky | 6eb4d5e | 2018-06-03 12:00:20 +0100 | [diff] [blame] | 171 | current_inline_infos_.push_back(entry); |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 172 | |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 173 | if (kVerifyStackMaps) { |
| 174 | size_t stack_map_index = stack_maps_.size(); |
David Srbecky | 6eb4d5e | 2018-06-03 12:00:20 +0100 | [diff] [blame] | 175 | size_t depth = current_inline_infos_.size() - 1; |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 176 | dchecks_.emplace_back([=](const CodeInfo& code_info) { |
| 177 | StackMap stack_map = code_info.GetStackMapAt(stack_map_index); |
David Srbecky | 6e69e52 | 2018-06-03 12:00:14 +0100 | [diff] [blame] | 178 | InlineInfo inline_info = code_info.GetInlineInfoAtDepth(stack_map, depth); |
| 179 | CHECK_EQ(inline_info.GetDexPc(), dex_pc); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 180 | bool encode_art_method = EncodeArtMethodInInlineInfo(method); |
David Srbecky | 6e69e52 | 2018-06-03 12:00:14 +0100 | [diff] [blame] | 181 | CHECK_EQ(inline_info.EncodesArtMethod(), encode_art_method); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 182 | if (encode_art_method) { |
David Srbecky | 6e69e52 | 2018-06-03 12:00:14 +0100 | [diff] [blame] | 183 | CHECK_EQ(inline_info.GetArtMethod(), method); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 184 | } else { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 185 | CHECK_EQ(method_infos_[inline_info.GetMethodInfoIndex()][0], |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 186 | method->GetDexMethodIndexUnchecked()); |
| 187 | } |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 188 | }); |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 189 | } |
Nicolas Geoffray | b1d0f3f | 2015-05-14 12:41:51 +0100 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | void StackMapStream::EndInlineInfoEntry() { |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 193 | DCHECK(in_inline_info_) << "Mismatched Begin/End calls"; |
| 194 | in_inline_info_ = false; |
| 195 | DCHECK_EQ(expected_num_dex_registers_, current_dex_registers_.size()); |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 196 | } |
| 197 | |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 198 | // Create delta-compressed dex register map based on the current list of DexRegisterLocations. |
| 199 | // All dex registers for a stack map are concatenated - inlined registers are just appended. |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 200 | void StackMapStream::CreateDexRegisterMap() { |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 201 | // These are fields rather than local variables so that we can reuse the reserved memory. |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 202 | temp_dex_register_mask_.ClearAllBits(); |
| 203 | temp_dex_register_map_.clear(); |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 204 | |
| 205 | // Ensure that the arrays that hold previous state are big enough to be safely indexed below. |
| 206 | if (previous_dex_registers_.size() < current_dex_registers_.size()) { |
| 207 | previous_dex_registers_.resize(current_dex_registers_.size(), DexRegisterLocation::None()); |
| 208 | dex_register_timestamp_.resize(current_dex_registers_.size(), 0u); |
| 209 | } |
| 210 | |
| 211 | // Set bit in the mask for each register that has been changed since the previous stack map. |
| 212 | // Modified registers are stored in the catalogue and the catalogue index added to the list. |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 213 | for (size_t i = 0; i < current_dex_registers_.size(); i++) { |
| 214 | DexRegisterLocation reg = current_dex_registers_[i]; |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 215 | // Distance is difference between this index and the index of last modification. |
| 216 | uint32_t distance = stack_maps_.size() - dex_register_timestamp_[i]; |
| 217 | if (previous_dex_registers_[i] != reg || distance > kMaxDexRegisterMapSearchDistance) { |
David Srbecky | cf7833e | 2018-06-14 16:45:22 +0100 | [diff] [blame] | 218 | BitTableBuilder<DexRegisterInfo>::Entry entry; |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 219 | entry[DexRegisterInfo::kKind] = static_cast<uint32_t>(reg.GetKind()); |
| 220 | entry[DexRegisterInfo::kPackedValue] = |
| 221 | DexRegisterInfo::PackValue(reg.GetKind(), reg.GetValue()); |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 222 | uint32_t index = reg.IsLive() ? dex_register_catalog_.Dedup(&entry) : kNoValue; |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 223 | temp_dex_register_mask_.SetBit(i); |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 224 | temp_dex_register_map_.push_back({index}); |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 225 | previous_dex_registers_[i] = reg; |
| 226 | dex_register_timestamp_[i] = stack_maps_.size(); |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 227 | } |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 228 | } |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 229 | |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 230 | // Set the mask and map for the current StackMap (which includes inlined registers). |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 231 | if (temp_dex_register_mask_.GetNumberOfBits() != 0) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 232 | current_stack_map_[StackMap::kDexRegisterMaskIndex] = |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 233 | dex_register_masks_.Dedup(temp_dex_register_mask_.GetRawStorage(), |
| 234 | temp_dex_register_mask_.GetNumberOfBits()); |
Vladimir Marko | 225b646 | 2015-09-28 12:17:40 +0100 | [diff] [blame] | 235 | } |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 236 | if (!current_dex_registers_.empty()) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 237 | current_stack_map_[StackMap::kDexRegisterMapIndex] = |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 238 | dex_register_maps_.Dedup(temp_dex_register_map_.data(), |
| 239 | temp_dex_register_map_.size()); |
David Srbecky | 052f8ca | 2018-04-26 15:42:54 +0100 | [diff] [blame] | 240 | } |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 241 | |
| 242 | if (kVerifyStackMaps) { |
| 243 | size_t stack_map_index = stack_maps_.size(); |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 244 | uint32_t depth = current_inline_infos_.size(); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 245 | // We need to make copy of the current registers for later (when the check is run). |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 246 | auto expected_dex_registers = std::make_shared<dchecked_vector<DexRegisterLocation>>( |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 247 | current_dex_registers_.begin(), current_dex_registers_.end()); |
| 248 | dchecks_.emplace_back([=](const CodeInfo& code_info) { |
| 249 | StackMap stack_map = code_info.GetStackMapAt(stack_map_index); |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 250 | uint32_t expected_reg = 0; |
| 251 | for (DexRegisterLocation reg : code_info.GetDexRegisterMapOf(stack_map)) { |
| 252 | CHECK_EQ((*expected_dex_registers)[expected_reg++], reg); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 253 | } |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 254 | for (uint32_t d = 0; d < depth; d++) { |
| 255 | for (DexRegisterLocation reg : code_info.GetDexRegisterMapAtDepth(d, stack_map)) { |
| 256 | CHECK_EQ((*expected_dex_registers)[expected_reg++], reg); |
| 257 | } |
| 258 | } |
| 259 | CHECK_EQ(expected_reg, expected_dex_registers->size()); |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 260 | }); |
| 261 | } |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 262 | } |
| 263 | |
Mathieu Chartier | cbcedbf | 2017-03-12 22:24:50 -0700 | [diff] [blame] | 264 | void StackMapStream::FillInMethodInfo(MemoryRegion region) { |
| 265 | { |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 266 | MethodInfo info(region.begin(), method_infos_.size()); |
| 267 | for (size_t i = 0; i < method_infos_.size(); ++i) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 268 | info.SetMethodIndex(i, method_infos_[i][0]); |
Mathieu Chartier | cbcedbf | 2017-03-12 22:24:50 -0700 | [diff] [blame] | 269 | } |
| 270 | } |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 271 | if (kVerifyStackMaps) { |
Mathieu Chartier | cbcedbf | 2017-03-12 22:24:50 -0700 | [diff] [blame] | 272 | // Check the data matches. |
| 273 | MethodInfo info(region.begin()); |
| 274 | const size_t count = info.NumMethodIndices(); |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 275 | DCHECK_EQ(count, method_infos_.size()); |
Mathieu Chartier | cbcedbf | 2017-03-12 22:24:50 -0700 | [diff] [blame] | 276 | for (size_t i = 0; i < count; ++i) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 277 | DCHECK_EQ(info.GetMethodIndex(i), method_infos_[i][0]); |
Mathieu Chartier | cbcedbf | 2017-03-12 22:24:50 -0700 | [diff] [blame] | 278 | } |
| 279 | } |
| 280 | } |
| 281 | |
David Srbecky | 052f8ca | 2018-04-26 15:42:54 +0100 | [diff] [blame] | 282 | size_t StackMapStream::PrepareForFillIn() { |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 283 | DCHECK_EQ(out_.size(), 0u); |
| 284 | |
| 285 | // Read the stack masks now. The compiler might have updated them. |
| 286 | for (size_t i = 0; i < lazy_stack_masks_.size(); i++) { |
| 287 | BitVector* stack_mask = lazy_stack_masks_[i]; |
| 288 | if (stack_mask != nullptr && stack_mask->GetNumberOfBits() != 0) { |
David Srbecky | f325e28 | 2018-06-13 15:02:32 +0100 | [diff] [blame] | 289 | stack_maps_[i][StackMap::kStackMaskIndex] = |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 290 | stack_masks_.Dedup(stack_mask->GetRawStorage(), stack_mask->GetNumberOfBits()); |
| 291 | } |
| 292 | } |
| 293 | |
David Srbecky | 052f8ca | 2018-04-26 15:42:54 +0100 | [diff] [blame] | 294 | size_t bit_offset = 0; |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 295 | stack_maps_.Encode(&out_, &bit_offset); |
| 296 | register_masks_.Encode(&out_, &bit_offset); |
| 297 | stack_masks_.Encode(&out_, &bit_offset); |
| 298 | invoke_infos_.Encode(&out_, &bit_offset); |
| 299 | inline_infos_.Encode(&out_, &bit_offset); |
| 300 | dex_register_masks_.Encode(&out_, &bit_offset); |
| 301 | dex_register_maps_.Encode(&out_, &bit_offset); |
| 302 | dex_register_catalog_.Encode(&out_, &bit_offset); |
David Srbecky | 6de8833 | 2018-06-03 12:00:11 +0100 | [diff] [blame] | 303 | EncodeVarintBits(&out_, &bit_offset, num_dex_registers_); |
David Srbecky | 45aa598 | 2016-03-18 02:15:09 +0000 | [diff] [blame] | 304 | |
David Srbecky | 052f8ca | 2018-04-26 15:42:54 +0100 | [diff] [blame] | 305 | return UnsignedLeb128Size(out_.size()) + out_.size(); |
| 306 | } |
| 307 | |
| 308 | void StackMapStream::FillInCodeInfo(MemoryRegion region) { |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 309 | DCHECK(in_stack_map_ == false) << "Mismatched Begin/End calls"; |
| 310 | DCHECK(in_inline_info_ == false) << "Mismatched Begin/End calls"; |
David Srbecky | 052f8ca | 2018-04-26 15:42:54 +0100 | [diff] [blame] | 311 | DCHECK_NE(0u, out_.size()) << "PrepareForFillIn not called before FillIn"; |
| 312 | DCHECK_EQ(region.size(), UnsignedLeb128Size(out_.size()) + out_.size()); |
| 313 | |
| 314 | uint8_t* ptr = EncodeUnsignedLeb128(region.begin(), out_.size()); |
| 315 | region.CopyFromVector(ptr - region.begin(), out_); |
Mathieu Chartier | 1a20b68 | 2017-01-31 14:25:16 -0800 | [diff] [blame] | 316 | |
David Srbecky | 049d681 | 2018-05-18 14:46:49 +0100 | [diff] [blame] | 317 | // Verify all written data (usually only in debug builds). |
| 318 | if (kVerifyStackMaps) { |
| 319 | CodeInfo code_info(region); |
| 320 | CHECK_EQ(code_info.GetNumberOfStackMaps(), stack_maps_.size()); |
| 321 | for (const auto& dcheck : dchecks_) { |
| 322 | dcheck(code_info); |
David Srbecky | 1bbdfd7 | 2016-02-24 16:39:26 +0000 | [diff] [blame] | 323 | } |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 324 | } |
David Srbecky | 1bbdfd7 | 2016-02-24 16:39:26 +0000 | [diff] [blame] | 325 | } |
| 326 | |
Mathieu Chartier | cbcedbf | 2017-03-12 22:24:50 -0700 | [diff] [blame] | 327 | size_t StackMapStream::ComputeMethodInfoSize() const { |
David Srbecky | 052f8ca | 2018-04-26 15:42:54 +0100 | [diff] [blame] | 328 | DCHECK_NE(0u, out_.size()) << "PrepareForFillIn not called before " << __FUNCTION__; |
David Srbecky | 71ec1cc | 2018-05-18 15:57:25 +0100 | [diff] [blame] | 329 | return MethodInfo::ComputeSize(method_infos_.size()); |
Mathieu Chartier | cbcedbf | 2017-03-12 22:24:50 -0700 | [diff] [blame] | 330 | } |
| 331 | |
Calin Juravle | c416d33 | 2015-04-23 16:01:43 +0100 | [diff] [blame] | 332 | } // namespace art |