1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
// Copyright 2011 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_CODEGEN_SAFEPOINT_TABLE_H_
#define V8_CODEGEN_SAFEPOINT_TABLE_H_
#include "src/base/memory.h"
#include "src/common/assert-scope.h"
#include "src/utils/allocation.h"
#include "src/utils/utils.h"
#include "src/zone/zone-chunk-list.h"
#include "src/zone/zone.h"
namespace v8 {
namespace internal {
class SafepointEntry {
public:
SafepointEntry() : deopt_index_(0), bits_(nullptr), trampoline_pc_(-1) {}
SafepointEntry(unsigned deopt_index, uint8_t* bits, int trampoline_pc)
: deopt_index_(deopt_index), bits_(bits), trampoline_pc_(trampoline_pc) {
DCHECK(is_valid());
}
bool is_valid() const { return bits_ != nullptr; }
bool Equals(const SafepointEntry& other) const {
return deopt_index_ == other.deopt_index_ && bits_ == other.bits_;
}
void Reset() {
deopt_index_ = 0;
bits_ = nullptr;
}
int trampoline_pc() { return trampoline_pc_; }
static const unsigned kNoDeoptIndex = kMaxUInt32;
int deoptimization_index() const {
DCHECK(is_valid() && has_deoptimization_index());
return deopt_index_;
}
bool has_deoptimization_index() const {
DCHECK(is_valid());
return deopt_index_ != kNoDeoptIndex;
}
uint8_t* bits() {
DCHECK(is_valid());
return bits_;
}
private:
unsigned deopt_index_;
uint8_t* bits_;
// It needs to be an integer as it is -1 for eager deoptimizations.
int trampoline_pc_;
};
class SafepointTable {
public:
explicit SafepointTable(Code code);
explicit SafepointTable(Address instruction_start,
size_t safepoint_table_offset, uint32_t stack_slots,
bool has_deopt = false);
int size() const {
return kHeaderSize + (length_ * (kFixedEntrySize + entry_size_));
}
unsigned length() const { return length_; }
unsigned entry_size() const { return entry_size_; }
unsigned GetPcOffset(unsigned index) const {
DCHECK(index < length_);
return base::Memory<uint32_t>(GetPcOffsetLocation(index));
}
int GetTrampolinePcOffset(unsigned index) const {
DCHECK(index < length_);
return base::Memory<int>(GetTrampolineLocation(index));
}
unsigned find_return_pc(unsigned pc_offset);
SafepointEntry GetEntry(unsigned index) const {
DCHECK(index < length_);
unsigned deopt_index =
base::Memory<uint32_t>(GetEncodedInfoLocation(index));
uint8_t* bits = &base::Memory<uint8_t>(entries_ + (index * entry_size_));
int trampoline_pc =
has_deopt_ ? base::Memory<int>(GetTrampolineLocation(index)) : -1;
return SafepointEntry(deopt_index, bits, trampoline_pc);
}
// Returns the entry for the given pc.
SafepointEntry FindEntry(Address pc) const;
void PrintEntry(unsigned index, std::ostream& os) const; // NOLINT
private:
static const uint8_t kNoRegisters = 0xFF;
// Layout information
static const int kLengthOffset = 0;
static const int kEntrySizeOffset = kLengthOffset + kIntSize;
static const int kHeaderSize = kEntrySizeOffset + kIntSize;
static const int kPcOffset = 0;
static const int kEncodedInfoOffset = kPcOffset + kIntSize;
static const int kTrampolinePcOffset = kEncodedInfoOffset + kIntSize;
static const int kFixedEntrySize = kTrampolinePcOffset + kIntSize;
Address GetPcOffsetLocation(unsigned index) const {
return pc_and_deoptimization_indexes_ + (index * kFixedEntrySize);
}
Address GetEncodedInfoLocation(unsigned index) const {
return GetPcOffsetLocation(index) + kEncodedInfoOffset;
}
Address GetTrampolineLocation(unsigned index) const {
return GetPcOffsetLocation(index) + kTrampolinePcOffset;
}
static void PrintBits(std::ostream& os, // NOLINT
uint8_t byte, int digits);
DISALLOW_HEAP_ALLOCATION(no_allocation_)
Address instruction_start_;
uint32_t stack_slots_;
unsigned length_;
unsigned entry_size_;
Address pc_and_deoptimization_indexes_;
Address entries_;
bool has_deopt_;
friend class SafepointTableBuilder;
friend class SafepointEntry;
DISALLOW_COPY_AND_ASSIGN(SafepointTable);
};
class Safepoint {
public:
enum DeoptMode { kNoLazyDeopt, kLazyDeopt };
static const int kNoDeoptimizationIndex = SafepointEntry::kNoDeoptIndex;
void DefinePointerSlot(int index) { indexes_->push_back(index); }
private:
explicit Safepoint(ZoneChunkList<int>* indexes) : indexes_(indexes) {}
ZoneChunkList<int>* const indexes_;
friend class SafepointTableBuilder;
};
class SafepointTableBuilder {
public:
explicit SafepointTableBuilder(Zone* zone)
: deoptimization_info_(zone),
emitted_(false),
zone_(zone) {}
// Get the offset of the emitted safepoint table in the code.
unsigned GetCodeOffset() const;
// Define a new safepoint for the current position in the body.
Safepoint DefineSafepoint(Assembler* assembler, Safepoint::DeoptMode mode);
// Emit the safepoint table after the body. The number of bits per
// entry must be enough to hold all the pointer indexes.
V8_EXPORT_PRIVATE void Emit(Assembler* assembler, int bits_per_entry);
// Find the Deoptimization Info with pc offset {pc} and update its
// trampoline field. Calling this function ensures that the safepoint
// table contains the trampoline PC {trampoline} that replaced the
// return PC {pc} on the stack.
int UpdateDeoptimizationInfo(int pc, int trampoline, int start,
unsigned deopt_index);
private:
struct DeoptimizationInfo {
unsigned pc;
unsigned deopt_index;
int trampoline;
ZoneChunkList<int>* indexes;
DeoptimizationInfo(Zone* zone, unsigned pc)
: pc(pc),
deopt_index(Safepoint::kNoDeoptimizationIndex),
trampoline(-1),
indexes(new (zone) ZoneChunkList<int>(
zone, ZoneChunkList<int>::StartMode::kSmall)) {}
};
// Compares all fields of a {DeoptimizationInfo} except {pc} and {trampoline}.
bool IsIdenticalExceptForPc(const DeoptimizationInfo&,
const DeoptimizationInfo&) const;
// If all entries are identical, replace them by 1 entry with pc = kMaxUInt32.
void RemoveDuplicates();
ZoneChunkList<DeoptimizationInfo> deoptimization_info_;
unsigned offset_;
bool emitted_;
Zone* zone_;
DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
};
} // namespace internal
} // namespace v8
#endif // V8_CODEGEN_SAFEPOINT_TABLE_H_
|
