blob: 26b95b0c2b8e52816c7a40892cf94292216c8ee4 [file] [log] [blame]
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +01001/*
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_RUNTIME_STACK_MAP_H_
18#define ART_RUNTIME_STACK_MAP_H_
19
Andreas Gampe69489fa2017-06-08 18:03:25 -070020#include <limits>
21
David Srbeckyf6ba5b32018-06-23 22:05:49 +010022#include "arch/instruction_set.h"
David Sehr1ce2b3b2018-04-05 11:02:03 -070023#include "base/bit_memory_region.h"
David Srbecky052f8ca2018-04-26 15:42:54 +010024#include "base/bit_table.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010025#include "base/bit_utils.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070026#include "base/bit_vector.h"
David Sehr67bf42e2018-02-26 16:43:04 -080027#include "base/leb128.h"
David Sehr1ce2b3b2018-04-05 11:02:03 -070028#include "base/memory_region.h"
David Sehr9e734c72018-01-04 17:56:19 -080029#include "dex/dex_file_types.h"
David Srbecky71ec1cc2018-05-18 15:57:25 +010030#include "dex_register_location.h"
Mathieu Chartiercbcedbf2017-03-12 22:24:50 -070031#include "method_info.h"
David Srbeckyf6ba5b32018-06-23 22:05:49 +010032#include "quick/quick_method_frame_info.h"
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +010033
34namespace art {
35
David Srbeckyf6ba5b32018-06-23 22:05:49 +010036class OatQuickMethodHeader;
Vladimir Marko8f1e08a2015-06-26 12:06:30 +010037class VariableIndentationOutputStream;
38
Roland Levillaina2d8ec62015-03-12 15:25:29 +000039// Size of a frame slot, in bytes. This constant is a signed value,
40// to please the compiler in arithmetic operations involving int32_t
41// (signed) values.
Roland Levillaina552e1c2015-03-26 15:01:03 +000042static constexpr ssize_t kFrameSlotSize = 4;
Roland Levillaina2d8ec62015-03-12 15:25:29 +000043
David Srbecky6de88332018-06-03 12:00:11 +010044// The delta compression of dex register maps means we need to scan the stackmaps backwards.
45// We compress the data in such a way so that there is an upper bound on the search distance.
46// Max distance 0 means each stack map must be fully defined and no scanning back is allowed.
47// If this value is changed, the oat file version should be incremented (for DCHECK to pass).
48static constexpr size_t kMaxDexRegisterMapSearchDistance = 32;
49
Nicolas Geoffray5d37c152017-01-12 13:25:19 +000050class ArtMethod;
Nicolas Geoffray004c2302015-03-20 10:06:38 +000051class CodeInfo;
David Srbecky86decb62018-06-05 06:41:10 +010052class Stats;
Nicolas Geoffray004c2302015-03-20 10:06:38 +000053
David Srbecky71ec1cc2018-05-18 15:57:25 +010054std::ostream& operator<<(std::ostream& stream, const DexRegisterLocation& reg);
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +010055
David Srbecky71ec1cc2018-05-18 15:57:25 +010056// Information on Dex register locations for a specific PC.
57// Effectively just a convenience wrapper for DexRegisterLocation vector.
58// If the size is small enough, it keeps the data on the stack.
David Srbeckye1402122018-06-13 18:20:45 +010059// TODO: Replace this with generic purpose "small-vector" implementation.
Roland Levillaina552e1c2015-03-26 15:01:03 +000060class DexRegisterMap {
61 public:
David Srbecky6de88332018-06-03 12:00:11 +010062 using iterator = DexRegisterLocation*;
David Srbeckye1402122018-06-13 18:20:45 +010063 using const_iterator = const DexRegisterLocation*;
David Srbecky6de88332018-06-03 12:00:11 +010064
65 // Create map for given number of registers and initialize them to the given value.
66 DexRegisterMap(size_t count, DexRegisterLocation value) : count_(count), regs_small_{} {
David Srbecky71ec1cc2018-05-18 15:57:25 +010067 if (count_ <= kSmallCount) {
David Srbecky6de88332018-06-03 12:00:11 +010068 std::fill_n(regs_small_.begin(), count, value);
David Srbecky71ec1cc2018-05-18 15:57:25 +010069 } else {
David Srbecky6de88332018-06-03 12:00:11 +010070 regs_large_.resize(count, value);
David Srbecky71ec1cc2018-05-18 15:57:25 +010071 }
Roland Levillaina552e1c2015-03-26 15:01:03 +000072 }
73
David Srbecky71ec1cc2018-05-18 15:57:25 +010074 DexRegisterLocation* data() {
75 return count_ <= kSmallCount ? regs_small_.data() : regs_large_.data();
76 }
David Srbeckye1402122018-06-13 18:20:45 +010077 const DexRegisterLocation* data() const {
78 return count_ <= kSmallCount ? regs_small_.data() : regs_large_.data();
79 }
Roland Levillaina552e1c2015-03-26 15:01:03 +000080
David Srbecky6de88332018-06-03 12:00:11 +010081 iterator begin() { return data(); }
82 iterator end() { return data() + count_; }
David Srbeckye1402122018-06-13 18:20:45 +010083 const_iterator begin() const { return data(); }
84 const_iterator end() const { return data() + count_; }
David Srbecky71ec1cc2018-05-18 15:57:25 +010085 size_t size() const { return count_; }
David Srbeckyfd89b072018-06-03 12:00:22 +010086 bool empty() const { return count_ == 0; }
David Srbecky71ec1cc2018-05-18 15:57:25 +010087
David Srbeckye1402122018-06-13 18:20:45 +010088 DexRegisterLocation& operator[](size_t index) {
David Srbecky71ec1cc2018-05-18 15:57:25 +010089 DCHECK_LT(index, count_);
David Srbeckye1402122018-06-13 18:20:45 +010090 return data()[index];
David Srbecky71ec1cc2018-05-18 15:57:25 +010091 }
David Srbeckye1402122018-06-13 18:20:45 +010092 const DexRegisterLocation& operator[](size_t index) const {
93 DCHECK_LT(index, count_);
94 return data()[index];
Roland Levillaina552e1c2015-03-26 15:01:03 +000095 }
96
David Srbecky71ec1cc2018-05-18 15:57:25 +010097 size_t GetNumberOfLiveDexRegisters() const {
David Srbeckye1402122018-06-13 18:20:45 +010098 return std::count_if(begin(), end(), [](auto& loc) { return loc.IsLive(); });
Roland Levillaina552e1c2015-03-26 15:01:03 +000099 }
100
David Srbecky71ec1cc2018-05-18 15:57:25 +0100101 bool HasAnyLiveDexRegisters() const {
David Srbeckye1402122018-06-13 18:20:45 +0100102 return std::any_of(begin(), end(), [](auto& loc) { return loc.IsLive(); });
David Srbecky21d45b42018-05-30 06:35:05 +0100103 }
104
David Srbeckye1402122018-06-13 18:20:45 +0100105 void Dump(VariableIndentationOutputStream* vios) const;
106
Roland Levillaina552e1c2015-03-26 15:01:03 +0000107 private:
David Srbecky71ec1cc2018-05-18 15:57:25 +0100108 // Store the data inline if the number of registers is small to avoid memory allocations.
109 // If count_ <= kSmallCount, we use the regs_small_ array, and regs_large_ otherwise.
110 static constexpr size_t kSmallCount = 16;
111 size_t count_;
112 std::array<DexRegisterLocation, kSmallCount> regs_small_;
113 dchecked_vector<DexRegisterLocation> regs_large_;
Roland Levillaina552e1c2015-03-26 15:01:03 +0000114};
115
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100116/**
117 * A Stack Map holds compilation information for a specific PC necessary for:
118 * - Mapping it to a dex PC,
119 * - Knowing which stack entries are objects,
120 * - Knowing which registers hold objects,
121 * - Knowing the inlining information,
122 * - Knowing the values of dex registers.
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100123 */
David Srbeckycf7833e2018-06-14 16:45:22 +0100124class StackMap : public BitTableAccessor<8> {
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100125 public:
David Srbecky50fac062018-06-13 18:55:35 +0100126 enum Kind {
127 Default = -1,
128 Catch = 0,
129 OSR = 1,
130 Debug = 2,
131 };
David Srbeckyd97e0822018-06-03 12:00:24 +0100132 BIT_TABLE_HEADER()
David Srbecky50fac062018-06-13 18:55:35 +0100133 BIT_TABLE_COLUMN(0, Kind)
134 BIT_TABLE_COLUMN(1, PackedNativePc)
135 BIT_TABLE_COLUMN(2, DexPc)
136 BIT_TABLE_COLUMN(3, RegisterMaskIndex)
137 BIT_TABLE_COLUMN(4, StackMaskIndex)
138 BIT_TABLE_COLUMN(5, InlineInfoIndex)
139 BIT_TABLE_COLUMN(6, DexRegisterMaskIndex)
140 BIT_TABLE_COLUMN(7, DexRegisterMapIndex)
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100141
David Srbecky052f8ca2018-04-26 15:42:54 +0100142 ALWAYS_INLINE uint32_t GetNativePcOffset(InstructionSet instruction_set) const {
David Srbeckycf7833e2018-06-14 16:45:22 +0100143 return UnpackNativePc(GetPackedNativePc(), instruction_set);
David Brazdilf677ebf2015-05-29 16:29:43 +0100144 }
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100145
David Srbeckyd97e0822018-06-03 12:00:24 +0100146 ALWAYS_INLINE bool HasInlineInfo() const {
147 return HasInlineInfoIndex();
148 }
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100149
David Srbeckyd97e0822018-06-03 12:00:24 +0100150 ALWAYS_INLINE bool HasDexRegisterMap() const {
151 return HasDexRegisterMapIndex();
152 }
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100153
David Srbeckyd02b23f2018-05-29 23:27:22 +0100154 static uint32_t PackNativePc(uint32_t native_pc, InstructionSet isa) {
David Srbeckyd775f962018-05-30 18:12:52 +0100155 DCHECK_ALIGNED_PARAM(native_pc, GetInstructionSetInstructionAlignment(isa));
David Srbeckyd02b23f2018-05-29 23:27:22 +0100156 return native_pc / GetInstructionSetInstructionAlignment(isa);
157 }
158
159 static uint32_t UnpackNativePc(uint32_t packed_native_pc, InstructionSet isa) {
160 uint32_t native_pc = packed_native_pc * GetInstructionSetInstructionAlignment(isa);
161 DCHECK_EQ(native_pc / GetInstructionSetInstructionAlignment(isa), packed_native_pc);
162 return native_pc;
163 }
164
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100165 void Dump(VariableIndentationOutputStream* vios,
Roland Levillainf2650d12015-05-28 14:53:28 +0100166 const CodeInfo& code_info,
Mathieu Chartiercbcedbf2017-03-12 22:24:50 -0700167 const MethodInfo& method_info,
Roland Levillainf2650d12015-05-28 14:53:28 +0100168 uint32_t code_offset,
David Srbecky71ec1cc2018-05-18 15:57:25 +0100169 InstructionSet instruction_set) const;
David Srbecky61b28a12016-02-25 21:55:03 +0000170};
171
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100172/**
David Srbecky052f8ca2018-04-26 15:42:54 +0100173 * Inline information for a specific PC.
174 * The row referenced from the StackMap holds information at depth 0.
175 * Following rows hold information for further depths.
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100176 */
David Srbeckycf7833e2018-06-14 16:45:22 +0100177class InlineInfo : public BitTableAccessor<6> {
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100178 public:
David Srbeckyd97e0822018-06-03 12:00:24 +0100179 BIT_TABLE_HEADER()
180 BIT_TABLE_COLUMN(0, IsLast) // Determines if there are further rows for further depths.
181 BIT_TABLE_COLUMN(1, DexPc)
182 BIT_TABLE_COLUMN(2, MethodInfoIndex)
183 BIT_TABLE_COLUMN(3, ArtMethodHi) // High bits of ArtMethod*.
184 BIT_TABLE_COLUMN(4, ArtMethodLo) // Low bits of ArtMethod*.
David Srbecky6de88332018-06-03 12:00:11 +0100185 BIT_TABLE_COLUMN(5, NumberOfDexRegisters) // Includes outer levels and the main method.
David Srbeckyd97e0822018-06-03 12:00:24 +0100186 BIT_TABLE_COLUMN(6, DexRegisterMapIndex)
187
David Srbecky052f8ca2018-04-26 15:42:54 +0100188 static constexpr uint32_t kLast = -1;
189 static constexpr uint32_t kMore = 0;
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100190
David Srbecky6e69e522018-06-03 12:00:14 +0100191 uint32_t GetMethodIndex(const MethodInfo& method_info) const {
David Srbeckyd97e0822018-06-03 12:00:24 +0100192 return method_info.GetMethodIndex(GetMethodInfoIndex());
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100193 }
194
David Srbecky6e69e522018-06-03 12:00:14 +0100195 bool EncodesArtMethod() const {
David Srbeckyd97e0822018-06-03 12:00:24 +0100196 return HasArtMethodLo();
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100197 }
198
David Srbecky6e69e522018-06-03 12:00:14 +0100199 ArtMethod* GetArtMethod() const {
David Srbeckyd97e0822018-06-03 12:00:24 +0100200 uint64_t lo = GetArtMethodLo();
201 uint64_t hi = GetArtMethodHi();
David Srbecky71ec1cc2018-05-18 15:57:25 +0100202 return reinterpret_cast<ArtMethod*>((hi << 32) | lo);
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100203 }
204
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100205 void Dump(VariableIndentationOutputStream* vios,
David Srbecky61b28a12016-02-25 21:55:03 +0000206 const CodeInfo& info,
David Srbecky6e69e522018-06-03 12:00:14 +0100207 const StackMap& stack_map,
David Srbeckyfd89b072018-06-03 12:00:22 +0100208 const MethodInfo& method_info) const;
Mathieu Chartier575d3e62017-02-06 11:00:40 -0800209};
210
David Srbeckycf7833e2018-06-14 16:45:22 +0100211class MaskInfo : public BitTableAccessor<1> {
David Srbecky86decb62018-06-05 06:41:10 +0100212 public:
213 BIT_TABLE_HEADER()
214 BIT_TABLE_COLUMN(0, Mask)
215};
216
David Srbeckycf7833e2018-06-14 16:45:22 +0100217class DexRegisterMapInfo : public BitTableAccessor<1> {
David Srbecky86decb62018-06-05 06:41:10 +0100218 public:
219 BIT_TABLE_HEADER()
220 BIT_TABLE_COLUMN(0, CatalogueIndex)
221};
222
David Srbeckycf7833e2018-06-14 16:45:22 +0100223class DexRegisterInfo : public BitTableAccessor<2> {
David Srbecky71ec1cc2018-05-18 15:57:25 +0100224 public:
David Srbeckyd97e0822018-06-03 12:00:24 +0100225 BIT_TABLE_HEADER()
226 BIT_TABLE_COLUMN(0, Kind)
227 BIT_TABLE_COLUMN(1, PackedValue)
David Srbecky71ec1cc2018-05-18 15:57:25 +0100228
229 ALWAYS_INLINE DexRegisterLocation GetLocation() const {
David Srbeckyd97e0822018-06-03 12:00:24 +0100230 DexRegisterLocation::Kind kind = static_cast<DexRegisterLocation::Kind>(GetKind());
231 return DexRegisterLocation(kind, UnpackValue(kind, GetPackedValue()));
David Srbecky71ec1cc2018-05-18 15:57:25 +0100232 }
233
234 static uint32_t PackValue(DexRegisterLocation::Kind kind, uint32_t value) {
235 uint32_t packed_value = value;
236 if (kind == DexRegisterLocation::Kind::kInStack) {
237 DCHECK(IsAligned<kFrameSlotSize>(packed_value));
238 packed_value /= kFrameSlotSize;
239 }
240 return packed_value;
241 }
242
243 static uint32_t UnpackValue(DexRegisterLocation::Kind kind, uint32_t packed_value) {
244 uint32_t value = packed_value;
245 if (kind == DexRegisterLocation::Kind::kInStack) {
246 value *= kFrameSlotSize;
247 }
248 return value;
249 }
250};
251
David Srbecky4b59d102018-05-29 21:46:10 +0000252// Register masks tend to have many trailing zero bits (caller-saves are usually not encoded),
253// therefore it is worth encoding the mask as value+shift.
David Srbeckycf7833e2018-06-14 16:45:22 +0100254class RegisterMask : public BitTableAccessor<2> {
David Srbecky4b59d102018-05-29 21:46:10 +0000255 public:
David Srbeckyd97e0822018-06-03 12:00:24 +0100256 BIT_TABLE_HEADER()
257 BIT_TABLE_COLUMN(0, Value)
258 BIT_TABLE_COLUMN(1, Shift)
David Srbecky4b59d102018-05-29 21:46:10 +0000259
260 ALWAYS_INLINE uint32_t GetMask() const {
David Srbeckyd97e0822018-06-03 12:00:24 +0100261 return GetValue() << GetShift();
David Srbecky4b59d102018-05-29 21:46:10 +0000262 }
263};
264
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100265/**
266 * Wrapper around all compiler information collected for a method.
David Srbecky71ec1cc2018-05-18 15:57:25 +0100267 * See the Decode method at the end for the precise binary format.
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100268 */
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100269class CodeInfo {
270 public:
Nicolas Geoffray39468442014-09-02 15:17:15 +0100271 explicit CodeInfo(const void* data) {
David Srbecky052f8ca2018-04-26 15:42:54 +0100272 Decode(reinterpret_cast<const uint8_t*>(data));
Nicolas Geoffray39468442014-09-02 15:17:15 +0100273 }
274
David Srbecky052f8ca2018-04-26 15:42:54 +0100275 explicit CodeInfo(MemoryRegion region) : CodeInfo(region.begin()) {
David Srbeckya38e6cf2018-06-26 18:13:49 +0100276 DCHECK_EQ(Size(), region.size());
Nicolas Geoffray896f8f72015-03-30 15:44:25 +0100277 }
278
David Srbeckyf6ba5b32018-06-23 22:05:49 +0100279 explicit CodeInfo(const OatQuickMethodHeader* header);
Nicolas Geoffray896f8f72015-03-30 15:44:25 +0100280
David Srbecky052f8ca2018-04-26 15:42:54 +0100281 size_t Size() const {
David Srbeckya38e6cf2018-06-26 18:13:49 +0100282 return BitsToBytesRoundUp(size_in_bits_);
Roland Levillaina552e1c2015-03-26 15:01:03 +0000283 }
284
David Srbecky93bd3612018-07-02 19:30:18 +0100285 ALWAYS_INLINE const BitTable<StackMap>& GetStackMaps() const {
286 return stack_maps_;
Nicolas Geoffray39468442014-09-02 15:17:15 +0100287 }
288
David Srbecky052f8ca2018-04-26 15:42:54 +0100289 ALWAYS_INLINE StackMap GetStackMapAt(size_t index) const {
David Srbeckycf7833e2018-06-14 16:45:22 +0100290 return stack_maps_.GetRow(index);
David Srbecky45aa5982016-03-18 02:15:09 +0000291 }
292
David Srbecky052f8ca2018-04-26 15:42:54 +0100293 BitMemoryRegion GetStackMask(size_t index) const {
David Srbecky4b59d102018-05-29 21:46:10 +0000294 return stack_masks_.GetBitMemoryRegion(index);
Mathieu Chartier1a20b682017-01-31 14:25:16 -0800295 }
296
David Srbecky052f8ca2018-04-26 15:42:54 +0100297 BitMemoryRegion GetStackMaskOf(const StackMap& stack_map) const {
David Srbecky4b59d102018-05-29 21:46:10 +0000298 uint32_t index = stack_map.GetStackMaskIndex();
299 return (index == StackMap::kNoValue) ? BitMemoryRegion() : GetStackMask(index);
Mathieu Chartier1a20b682017-01-31 14:25:16 -0800300 }
301
David Srbecky052f8ca2018-04-26 15:42:54 +0100302 uint32_t GetRegisterMaskOf(const StackMap& stack_map) const {
David Srbecky4b59d102018-05-29 21:46:10 +0000303 uint32_t index = stack_map.GetRegisterMaskIndex();
David Srbeckycf7833e2018-06-14 16:45:22 +0100304 return (index == StackMap::kNoValue) ? 0 : register_masks_.GetRow(index).GetMask();
Nicolas Geoffray39468442014-09-02 15:17:15 +0100305 }
306
David Srbecky052f8ca2018-04-26 15:42:54 +0100307 uint32_t GetNumberOfLocationCatalogEntries() const {
David Srbecky71ec1cc2018-05-18 15:57:25 +0100308 return dex_register_catalog_.NumRows();
Roland Levillaina552e1c2015-03-26 15:01:03 +0000309 }
310
David Srbecky71ec1cc2018-05-18 15:57:25 +0100311 ALWAYS_INLINE DexRegisterLocation GetDexRegisterCatalogEntry(size_t index) const {
David Srbecky6de88332018-06-03 12:00:11 +0100312 return (index == StackMap::kNoValue)
313 ? DexRegisterLocation::None()
David Srbeckycf7833e2018-06-14 16:45:22 +0100314 : dex_register_catalog_.GetRow(index).GetLocation();
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100315 }
316
David Srbecky93bd3612018-07-02 19:30:18 +0100317 bool HasInlineInfo() const {
318 return inline_infos_.NumRows() > 0;
319 }
320
David Srbecky052f8ca2018-04-26 15:42:54 +0100321 uint32_t GetNumberOfStackMaps() const {
322 return stack_maps_.NumRows();
Nicolas Geoffray6530baf2015-05-26 15:22:58 +0100323 }
324
David Srbeckyfd89b072018-06-03 12:00:22 +0100325 ALWAYS_INLINE DexRegisterMap GetDexRegisterMapOf(StackMap stack_map) const {
David Srbecky6de88332018-06-03 12:00:11 +0100326 if (stack_map.HasDexRegisterMap()) {
327 DexRegisterMap map(number_of_dex_registers_, DexRegisterLocation::Invalid());
328 DecodeDexRegisterMap(stack_map.Row(), /* first_dex_register */ 0, &map);
329 return map;
330 }
331 return DexRegisterMap(0, DexRegisterLocation::None());
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100332 }
333
David Srbecky93bd3612018-07-02 19:30:18 +0100334 ALWAYS_INLINE DexRegisterMap GetInlineDexRegisterMapOf(StackMap stack_map,
335 InlineInfo inline_info) const {
David Srbecky6de88332018-06-03 12:00:11 +0100336 if (stack_map.HasDexRegisterMap()) {
David Srbecky93bd3612018-07-02 19:30:18 +0100337 DCHECK(stack_map.HasInlineInfoIndex());
338 uint32_t depth = inline_info.Row() - stack_map.GetInlineInfoIndex();
David Srbecky6de88332018-06-03 12:00:11 +0100339 // The register counts are commutative and include all outer levels.
340 // This allows us to determine the range [first, last) in just two lookups.
341 // If we are at depth 0 (the first inlinee), the count from the main method is used.
David Srbecky93bd3612018-07-02 19:30:18 +0100342 uint32_t first = (depth == 0)
343 ? number_of_dex_registers_
344 : inline_infos_.GetRow(inline_info.Row() - 1).GetNumberOfDexRegisters();
345 uint32_t last = inline_info.GetNumberOfDexRegisters();
David Srbecky6de88332018-06-03 12:00:11 +0100346 DexRegisterMap map(last - first, DexRegisterLocation::Invalid());
347 DecodeDexRegisterMap(stack_map.Row(), first, &map);
348 return map;
349 }
350 return DexRegisterMap(0, DexRegisterLocation::None());
Nicolas Geoffrayb1d0f3f2015-05-14 12:41:51 +0100351 }
352
David Srbecky93bd3612018-07-02 19:30:18 +0100353 BitTableRange<InlineInfo> GetInlineInfosOf(StackMap stack_map) const {
David Srbecky052f8ca2018-04-26 15:42:54 +0100354 uint32_t index = stack_map.GetInlineInfoIndex();
David Srbecky6e69e522018-06-03 12:00:14 +0100355 if (index != StackMap::kNoValue) {
David Srbecky93bd3612018-07-02 19:30:18 +0100356 auto begin = inline_infos_.begin() + index;
357 auto end = begin;
358 while ((*end++).GetIsLast() == InlineInfo::kMore) { }
359 return BitTableRange<InlineInfo>(begin, end);
360 } else {
361 return BitTableRange<InlineInfo>();
David Srbecky6e69e522018-06-03 12:00:14 +0100362 }
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100363 }
364
David Srbecky052f8ca2018-04-26 15:42:54 +0100365 StackMap GetStackMapForDexPc(uint32_t dex_pc) const {
David Srbecky93bd3612018-07-02 19:30:18 +0100366 for (StackMap stack_map : stack_maps_) {
David Srbecky50fac062018-06-13 18:55:35 +0100367 if (stack_map.GetDexPc() == dex_pc && stack_map.GetKind() != StackMap::Kind::Debug) {
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100368 return stack_map;
369 }
370 }
David Srbeckya45a85c2018-06-21 16:03:12 +0100371 return stack_maps_.GetInvalidRow();
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100372 }
373
David Srbecky50fac062018-06-13 18:55:35 +0100374 // Searches the stack map list backwards because catch stack maps are stored at the end.
David Srbecky052f8ca2018-04-26 15:42:54 +0100375 StackMap GetCatchStackMapForDexPc(uint32_t dex_pc) const {
376 for (size_t i = GetNumberOfStackMaps(); i > 0; --i) {
377 StackMap stack_map = GetStackMapAt(i - 1);
David Srbecky50fac062018-06-13 18:55:35 +0100378 if (stack_map.GetDexPc() == dex_pc && stack_map.GetKind() == StackMap::Kind::Catch) {
David Brazdil77a48ae2015-09-15 12:34:04 +0000379 return stack_map;
380 }
381 }
David Srbeckya45a85c2018-06-21 16:03:12 +0100382 return stack_maps_.GetInvalidRow();
David Brazdil77a48ae2015-09-15 12:34:04 +0000383 }
384
David Srbecky052f8ca2018-04-26 15:42:54 +0100385 StackMap GetOsrStackMapForDexPc(uint32_t dex_pc) const {
David Srbecky93bd3612018-07-02 19:30:18 +0100386 for (StackMap stack_map : stack_maps_) {
David Srbecky50fac062018-06-13 18:55:35 +0100387 if (stack_map.GetDexPc() == dex_pc && stack_map.GetKind() == StackMap::Kind::OSR) {
388 return stack_map;
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000389 }
390 }
David Srbeckya45a85c2018-06-21 16:03:12 +0100391 return stack_maps_.GetInvalidRow();
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000392 }
393
David Srbecky0b4e5a32018-06-11 16:25:29 +0100394 StackMap GetStackMapForNativePcOffset(uint32_t pc, InstructionSet isa = kRuntimeISA) const;
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100395
David Srbecky71ec1cc2018-05-18 15:57:25 +0100396 // Dump this CodeInfo object on `vios`.
397 // `code_offset` is the (absolute) native PC of the compiled method.
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100398 void Dump(VariableIndentationOutputStream* vios,
Roland Levillainf2650d12015-05-28 14:53:28 +0100399 uint32_t code_offset,
David Srbecky71ec1cc2018-05-18 15:57:25 +0100400 bool verbose,
Mathieu Chartiercbcedbf2017-03-12 22:24:50 -0700401 InstructionSet instruction_set,
402 const MethodInfo& method_info) const;
Nicolas Geoffray004c2302015-03-20 10:06:38 +0000403
David Srbecky86decb62018-06-05 06:41:10 +0100404 // Accumulate code info size statistics into the given Stats tree.
405 void AddSizeStats(/*out*/ Stats* parent) const;
406
David Srbeckyf6ba5b32018-06-23 22:05:49 +0100407 ALWAYS_INLINE static QuickMethodFrameInfo DecodeFrameInfo(const uint8_t* data) {
David Srbeckyf6ba5b32018-06-23 22:05:49 +0100408 return QuickMethodFrameInfo(
409 DecodeUnsignedLeb128(&data),
410 DecodeUnsignedLeb128(&data),
411 DecodeUnsignedLeb128(&data));
412 }
413
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100414 private:
David Srbecky0b4e5a32018-06-11 16:25:29 +0100415 // Returns lower bound (fist stack map which has pc greater or equal than the desired one).
416 // It ignores catch stack maps at the end (it is the same as if they had maximum pc value).
417 BitTable<StackMap>::const_iterator BinarySearchNativePc(uint32_t packed_pc) const;
418
David Srbecky6de88332018-06-03 12:00:11 +0100419 // Scan backward to determine dex register locations at given stack map.
420 void DecodeDexRegisterMap(uint32_t stack_map_index,
421 uint32_t first_dex_register,
422 /*out*/ DexRegisterMap* map) const;
Roland Levillaina2d8ec62015-03-12 15:25:29 +0000423
David Srbecky078d7ba2018-06-21 15:36:48 +0100424 void Decode(const uint8_t* data);
David Srbecky052f8ca2018-04-26 15:42:54 +0100425
David Srbeckyf6ba5b32018-06-23 22:05:49 +0100426 uint32_t frame_size_in_bytes_;
427 uint32_t core_spill_mask_;
428 uint32_t fp_spill_mask_;
429 uint32_t number_of_dex_registers_;
David Srbeckycf7833e2018-06-14 16:45:22 +0100430 BitTable<StackMap> stack_maps_;
431 BitTable<RegisterMask> register_masks_;
432 BitTable<MaskInfo> stack_masks_;
David Srbeckycf7833e2018-06-14 16:45:22 +0100433 BitTable<InlineInfo> inline_infos_;
434 BitTable<MaskInfo> dex_register_masks_;
435 BitTable<DexRegisterMapInfo> dex_register_maps_;
436 BitTable<DexRegisterInfo> dex_register_catalog_;
David Srbeckya38e6cf2018-06-26 18:13:49 +0100437 uint32_t size_in_bits_;
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100438};
439
Roland Levillain1c1da432015-07-16 11:54:44 +0100440#undef ELEMENT_BYTE_OFFSET_AFTER
441#undef ELEMENT_BIT_OFFSET_AFTER
442
Nicolas Geoffray99ea58c2014-07-02 15:08:17 +0100443} // namespace art
444
445#endif // ART_RUNTIME_STACK_MAP_H_