Line data Source code
1 : // Copyright 2016 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/eh-frame.h"
6 :
7 : #include <iomanip>
8 : #include <ostream>
9 :
10 : #if !defined(V8_TARGET_ARCH_X64) && !defined(V8_TARGET_ARCH_ARM) && \
11 : !defined(V8_TARGET_ARCH_ARM64)
12 :
13 : // Placeholders for unsupported architectures.
14 :
15 : namespace v8 {
16 : namespace internal {
17 :
18 : const int EhFrameConstants::kCodeAlignmentFactor = 1;
19 : const int EhFrameConstants::kDataAlignmentFactor = 1;
20 :
21 : void EhFrameWriter::WriteReturnAddressRegisterCode() { UNIMPLEMENTED(); }
22 :
23 : void EhFrameWriter::WriteInitialStateInCie() { UNIMPLEMENTED(); }
24 :
25 : int EhFrameWriter::RegisterToDwarfCode(Register) {
26 : UNIMPLEMENTED();
27 : return -1;
28 : }
29 :
30 : #ifdef ENABLE_DISASSEMBLER
31 :
32 : const char* EhFrameDisassembler::DwarfRegisterCodeToString(int) {
33 : UNIMPLEMENTED();
34 : return nullptr;
35 : }
36 :
37 : #endif
38 :
39 : } // namespace internal
40 : } // namespace v8
41 :
42 : #endif
43 :
44 : namespace v8 {
45 : namespace internal {
46 :
47 : STATIC_CONST_MEMBER_DEFINITION const int
48 : EhFrameConstants::kEhFrameTerminatorSize;
49 : STATIC_CONST_MEMBER_DEFINITION const int EhFrameConstants::kEhFrameHdrVersion;
50 : STATIC_CONST_MEMBER_DEFINITION const int EhFrameConstants::kEhFrameHdrSize;
51 :
52 : STATIC_CONST_MEMBER_DEFINITION const uint32_t EhFrameWriter::kInt32Placeholder;
53 :
54 : // static
55 0 : void EhFrameWriter::WriteEmptyEhFrame(std::ostream& stream) { // NOLINT
56 0 : stream.put(EhFrameConstants::kEhFrameHdrVersion);
57 :
58 : // .eh_frame pointer encoding specifier.
59 0 : stream.put(EhFrameConstants::kSData4 | EhFrameConstants::kPcRel);
60 :
61 : // Lookup table size encoding.
62 0 : stream.put(EhFrameConstants::kUData4);
63 :
64 : // Lookup table entries encoding.
65 0 : stream.put(EhFrameConstants::kSData4 | EhFrameConstants::kDataRel);
66 :
67 : // Dummy pointers and 0 entries in the lookup table.
68 0 : char dummy_data[EhFrameConstants::kEhFrameHdrSize - 4] = {0};
69 0 : stream.write(&dummy_data[0], sizeof(dummy_data));
70 0 : }
71 :
72 2949423 : EhFrameWriter::EhFrameWriter(Zone* zone)
73 : : cie_size_(0),
74 : last_pc_offset_(0),
75 : writer_state_(InternalState::kUndefined),
76 : base_register_(no_reg),
77 : base_offset_(0),
78 5898846 : eh_frame_buffer_(zone) {}
79 :
80 42 : void EhFrameWriter::Initialize() {
81 : DCHECK_EQ(writer_state_, InternalState::kUndefined);
82 42 : eh_frame_buffer_.reserve(128);
83 42 : writer_state_ = InternalState::kInitialized;
84 42 : WriteCie();
85 42 : WriteFdeHeader();
86 42 : }
87 :
88 42 : void EhFrameWriter::WriteCie() {
89 : static const int kCIEIdentifier = 0;
90 : static const int kCIEVersion = 3;
91 : static const int kAugmentationDataSize = 2;
92 : static const byte kAugmentationString[] = {'z', 'L', 'R', 0};
93 :
94 : // Placeholder for the size of the CIE.
95 : int size_offset = eh_frame_offset();
96 : WriteInt32(kInt32Placeholder);
97 :
98 : // CIE identifier and version.
99 : int record_start_offset = eh_frame_offset();
100 : WriteInt32(kCIEIdentifier);
101 : WriteByte(kCIEVersion);
102 :
103 : // Augmentation data contents descriptor: LSDA and FDE encoding.
104 : WriteBytes(&kAugmentationString[0], sizeof(kAugmentationString));
105 :
106 : // Alignment factors.
107 42 : WriteSLeb128(EhFrameConstants::kCodeAlignmentFactor);
108 42 : WriteSLeb128(EhFrameConstants::kDataAlignmentFactor);
109 :
110 42 : WriteReturnAddressRegisterCode();
111 :
112 : // Augmentation data.
113 42 : WriteULeb128(kAugmentationDataSize);
114 : // No language-specific data area (LSDA).
115 : WriteByte(EhFrameConstants::kOmit);
116 : // FDE pointers encoding.
117 : WriteByte(EhFrameConstants::kSData4 | EhFrameConstants::kPcRel);
118 :
119 : // Write directives to build the initial state of the unwinding table.
120 : DCHECK_EQ(eh_frame_offset() - size_offset,
121 : EhFrameConstants::kInitialStateOffsetInCie);
122 42 : WriteInitialStateInCie();
123 :
124 42 : WritePaddingToAlignedSize(eh_frame_offset() - record_start_offset);
125 :
126 : int record_end_offset = eh_frame_offset();
127 42 : int encoded_cie_size = record_end_offset - record_start_offset;
128 42 : cie_size_ = record_end_offset - size_offset;
129 :
130 : // Patch the size of the CIE now that we know it.
131 42 : PatchInt32(size_offset, encoded_cie_size);
132 42 : }
133 :
134 42 : void EhFrameWriter::WriteFdeHeader() {
135 : DCHECK_NE(cie_size_, 0);
136 :
137 : // Placeholder for size of the FDE. Will be filled in Finish().
138 : DCHECK_EQ(eh_frame_offset(), fde_offset());
139 : WriteInt32(kInt32Placeholder);
140 :
141 : // Backwards offset to the CIE.
142 42 : WriteInt32(cie_size_ + kInt32Size);
143 :
144 : // Placeholder for pointer to procedure. Will be filled in Finish().
145 : DCHECK_EQ(eh_frame_offset(), GetProcedureAddressOffset());
146 : WriteInt32(kInt32Placeholder);
147 :
148 : // Placeholder for size of the procedure. Will be filled in Finish().
149 : DCHECK_EQ(eh_frame_offset(), GetProcedureSizeOffset());
150 : WriteInt32(kInt32Placeholder);
151 :
152 : // No augmentation data.
153 : WriteByte(0);
154 42 : }
155 :
156 42 : void EhFrameWriter::WriteEhFrameHdr(int code_size) {
157 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
158 :
159 : //
160 : // In order to calculate offsets in the .eh_frame_hdr, we must know the layout
161 : // of the DSO generated by perf inject, which is assumed to be the following:
162 : //
163 : // | ... | |
164 : // +---------------+ <-- (F) --- | Larger offsets in file
165 : // | | ^ |
166 : // | Instructions | | .text v
167 : // | | v
168 : // +---------------+ <-- (E) ---
169 : // |///////////////|
170 : // |////Padding////|
171 : // |///////////////|
172 : // +---------------+ <-- (D) ---
173 : // | | ^
174 : // | CIE | |
175 : // | | |
176 : // +---------------+ <-- (C) |
177 : // | | | .eh_frame
178 : // | FDE | |
179 : // | | |
180 : // +---------------+ |
181 : // | terminator | v
182 : // +---------------+ <-- (B) ---
183 : // | version | ^
184 : // +---------------+ |
185 : // | encoding | |
186 : // | specifiers | |
187 : // +---------------+ <---(A) | .eh_frame_hdr
188 : // | offset to | |
189 : // | .eh_frame | |
190 : // +---------------+ |
191 : // | ... | ...
192 : //
193 : // (F) is aligned to a 16-byte boundary.
194 : // (D) is aligned to a 8-byte boundary.
195 : // (B) is aligned to a 4-byte boundary.
196 : // (C), (E) and (A) have no alignment requirements.
197 : //
198 : // The distance between (A) and (B) is 4 bytes.
199 : //
200 : // The size of the FDE is required to be a multiple of the pointer size, which
201 : // means that (B) will be naturally aligned to a 4-byte boundary on all the
202 : // architectures we support.
203 : //
204 : // Because (E) has no alignment requirements, there is padding between (E) and
205 : // (D). (F) is aligned at a 16-byte boundary, thus to a 8-byte one as well.
206 : //
207 :
208 : int eh_frame_size = eh_frame_offset();
209 :
210 : WriteByte(EhFrameConstants::kEhFrameHdrVersion);
211 :
212 : // .eh_frame pointer encoding specifier.
213 : WriteByte(EhFrameConstants::kSData4 | EhFrameConstants::kPcRel);
214 : // Lookup table size encoding specifier.
215 : WriteByte(EhFrameConstants::kUData4);
216 : // Lookup table entries encoding specifier.
217 : WriteByte(EhFrameConstants::kSData4 | EhFrameConstants::kDataRel);
218 :
219 : // Pointer to .eh_frame, relative to this offset (A -> D in the diagram).
220 : WriteInt32(-(eh_frame_size + EhFrameConstants::kFdeVersionSize +
221 42 : EhFrameConstants::kFdeEncodingSpecifiersSize));
222 :
223 : // Number of entries in the LUT, one for the only routine.
224 : WriteInt32(1);
225 :
226 : // Pointer to the start of the routine, relative to the beginning of the
227 : // .eh_frame_hdr (B -> F in the diagram).
228 42 : WriteInt32(-(RoundUp(code_size, 8) + eh_frame_size));
229 :
230 : // Pointer to the start of the associated FDE, relative to the start of the
231 : // .eh_frame_hdr (B -> C in the diagram).
232 42 : WriteInt32(-(eh_frame_size - cie_size_));
233 :
234 : DCHECK_EQ(eh_frame_offset() - eh_frame_size,
235 : EhFrameConstants::kEhFrameHdrSize);
236 42 : }
237 :
238 84 : void EhFrameWriter::WritePaddingToAlignedSize(int unpadded_size) {
239 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
240 : DCHECK_GE(unpadded_size, 0);
241 :
242 84 : int padding_size = RoundUp(unpadded_size, kSystemPointerSize) - unpadded_size;
243 :
244 : byte nop = static_cast<byte>(EhFrameConstants::DwarfOpcodes::kNop);
245 84 : static const byte kPadding[] = {nop, nop, nop, nop, nop, nop, nop, nop};
246 : DCHECK_LE(padding_size, static_cast<int>(sizeof(kPadding)));
247 : WriteBytes(&kPadding[0], padding_size);
248 84 : }
249 :
250 129 : void EhFrameWriter::AdvanceLocation(int pc_offset) {
251 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
252 : DCHECK_GE(pc_offset, last_pc_offset_);
253 129 : uint32_t delta = pc_offset - last_pc_offset_;
254 :
255 : DCHECK_EQ(delta % EhFrameConstants::kCodeAlignmentFactor, 0u);
256 129 : uint32_t factored_delta = delta / EhFrameConstants::kCodeAlignmentFactor;
257 :
258 129 : if (factored_delta <= EhFrameConstants::kLocationMask) {
259 : WriteByte((EhFrameConstants::kLocationTag
260 : << EhFrameConstants::kLocationMaskSize) |
261 106 : (factored_delta & EhFrameConstants::kLocationMask));
262 23 : } else if (factored_delta <= kMaxUInt8) {
263 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kAdvanceLoc1);
264 : WriteByte(factored_delta);
265 7 : } else if (factored_delta <= kMaxUInt16) {
266 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kAdvanceLoc2);
267 : WriteInt16(factored_delta);
268 : } else {
269 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kAdvanceLoc4);
270 : WriteInt32(factored_delta);
271 : }
272 :
273 129 : last_pc_offset_ = pc_offset;
274 129 : }
275 :
276 49 : void EhFrameWriter::SetBaseAddressOffset(int base_offset) {
277 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
278 : DCHECK_GE(base_offset, 0);
279 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kDefCfaOffset);
280 49 : WriteULeb128(base_offset);
281 49 : base_offset_ = base_offset;
282 49 : }
283 :
284 47 : void EhFrameWriter::SetBaseAddressRegister(Register base_register) {
285 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
286 47 : int code = RegisterToDwarfCode(base_register);
287 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kDefCfaRegister);
288 47 : WriteULeb128(code);
289 47 : base_register_ = base_register;
290 47 : }
291 :
292 66 : void EhFrameWriter::SetBaseAddressRegisterAndOffset(Register base_register,
293 : int base_offset) {
294 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
295 : DCHECK_GE(base_offset, 0);
296 66 : int code = RegisterToDwarfCode(base_register);
297 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kDefCfa);
298 66 : WriteULeb128(code);
299 66 : WriteULeb128(base_offset);
300 66 : base_offset_ = base_offset;
301 66 : base_register_ = base_register;
302 66 : }
303 :
304 67 : void EhFrameWriter::RecordRegisterSavedToStack(int register_code, int offset) {
305 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
306 : DCHECK_EQ(offset % EhFrameConstants::kDataAlignmentFactor, 0);
307 67 : int factored_offset = offset / EhFrameConstants::kDataAlignmentFactor;
308 67 : if (factored_offset >= 0) {
309 : DCHECK_LE(register_code, EhFrameConstants::kSavedRegisterMask);
310 : WriteByte((EhFrameConstants::kSavedRegisterTag
311 : << EhFrameConstants::kSavedRegisterMaskSize) |
312 66 : (register_code & EhFrameConstants::kSavedRegisterMask));
313 66 : WriteULeb128(factored_offset);
314 : } else {
315 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kOffsetExtendedSf);
316 1 : WriteULeb128(register_code);
317 1 : WriteSLeb128(factored_offset);
318 : }
319 67 : }
320 :
321 1 : void EhFrameWriter::RecordRegisterNotModified(Register name) {
322 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
323 : WriteOpcode(EhFrameConstants::DwarfOpcodes::kSameValue);
324 1 : WriteULeb128(RegisterToDwarfCode(name));
325 1 : }
326 :
327 1 : void EhFrameWriter::RecordRegisterFollowsInitialRule(Register name) {
328 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
329 1 : int code = RegisterToDwarfCode(name);
330 : DCHECK_LE(code, EhFrameConstants::kFollowInitialRuleMask);
331 : WriteByte((EhFrameConstants::kFollowInitialRuleTag
332 : << EhFrameConstants::kFollowInitialRuleMaskSize) |
333 1 : (code & EhFrameConstants::kFollowInitialRuleMask));
334 1 : }
335 :
336 126 : void EhFrameWriter::Finish(int code_size) {
337 : DCHECK_EQ(writer_state_, InternalState::kInitialized);
338 : DCHECK_GE(eh_frame_offset(), cie_size_);
339 :
340 : DCHECK_GE(eh_frame_offset(), fde_offset() + kInt32Size);
341 42 : WritePaddingToAlignedSize(eh_frame_offset() - fde_offset() - kInt32Size);
342 :
343 : // Write the size of the FDE now that we know it.
344 : // The encoded size does not include the size field itself.
345 42 : int encoded_fde_size = eh_frame_offset() - fde_offset() - kInt32Size;
346 42 : PatchInt32(fde_offset(), encoded_fde_size);
347 :
348 : // Write size and offset to procedure.
349 : PatchInt32(GetProcedureAddressOffset(),
350 42 : -(RoundUp(code_size, 8) + GetProcedureAddressOffset()));
351 : PatchInt32(GetProcedureSizeOffset(), code_size);
352 :
353 : // Terminate the .eh_frame.
354 : static const byte kTerminator[EhFrameConstants::kEhFrameTerminatorSize] = {0};
355 : WriteBytes(&kTerminator[0], EhFrameConstants::kEhFrameTerminatorSize);
356 :
357 42 : WriteEhFrameHdr(code_size);
358 :
359 42 : writer_state_ = InternalState::kFinalized;
360 42 : }
361 :
362 42 : void EhFrameWriter::GetEhFrame(CodeDesc* desc) {
363 : DCHECK_EQ(writer_state_, InternalState::kFinalized);
364 84 : desc->unwinding_info_size = static_cast<int>(eh_frame_buffer_.size());
365 42 : desc->unwinding_info = eh_frame_buffer_.data();
366 42 : }
367 :
368 380 : void EhFrameWriter::WriteULeb128(uint32_t value) {
369 388 : do {
370 388 : byte chunk = value & 0x7F;
371 388 : value >>= 7;
372 388 : if (value != 0) chunk |= 0x80;
373 : WriteByte(chunk);
374 : } while (value != 0);
375 380 : }
376 :
377 85 : void EhFrameWriter::WriteSLeb128(int32_t value) {
378 : static const int kSignBitMask = 0x40;
379 : bool done;
380 86 : do {
381 86 : byte chunk = value & 0x7F;
382 86 : value >>= 7;
383 86 : done = ((value == 0) && ((chunk & kSignBitMask) == 0)) ||
384 43 : ((value == -1) && ((chunk & kSignBitMask) != 0));
385 86 : if (!done) chunk |= 0x80;
386 : WriteByte(chunk);
387 : } while (!done);
388 85 : }
389 :
390 10 : uint32_t EhFrameIterator::GetNextULeb128() {
391 : int size = 0;
392 10 : uint32_t result = DecodeULeb128(next_, &size);
393 : DCHECK_LE(next_ + size, end_);
394 10 : next_ += size;
395 10 : return result;
396 : }
397 :
398 3 : int32_t EhFrameIterator::GetNextSLeb128() {
399 : int size = 0;
400 3 : int32_t result = DecodeSLeb128(next_, &size);
401 : DCHECK_LE(next_ + size, end_);
402 3 : next_ += size;
403 3 : return result;
404 : }
405 :
406 : // static
407 0 : uint32_t EhFrameIterator::DecodeULeb128(const byte* encoded,
408 : int* encoded_size) {
409 : const byte* current = encoded;
410 : uint32_t result = 0;
411 : int shift = 0;
412 :
413 20 : do {
414 : DCHECK_LT(shift, 8 * static_cast<int>(sizeof(result)));
415 20 : result |= (*current & 0x7F) << shift;
416 20 : shift += 7;
417 20 : } while (*current++ >= 128);
418 :
419 : DCHECK_NOT_NULL(encoded_size);
420 10 : *encoded_size = static_cast<int>(current - encoded);
421 :
422 0 : return result;
423 : }
424 :
425 : // static
426 0 : int32_t EhFrameIterator::DecodeSLeb128(const byte* encoded, int* encoded_size) {
427 : static const byte kSignBitMask = 0x40;
428 :
429 : const byte* current = encoded;
430 : int32_t result = 0;
431 : int shift = 0;
432 : byte chunk;
433 :
434 8 : do {
435 8 : chunk = *current++;
436 : DCHECK_LT(shift, 8 * static_cast<int>(sizeof(result)));
437 8 : result |= (chunk & 0x7F) << shift;
438 8 : shift += 7;
439 8 : } while (chunk >= 128);
440 :
441 : // Sign extend the result if the last chunk has the sign bit set.
442 3 : if (chunk & kSignBitMask) result |= (~0ull) << shift;
443 :
444 : DCHECK_NOT_NULL(encoded_size);
445 3 : *encoded_size = static_cast<int>(current - encoded);
446 :
447 0 : return result;
448 : }
449 :
450 : #ifdef ENABLE_DISASSEMBLER
451 :
452 : namespace {
453 :
454 : class StreamModifiersScope final {
455 : public:
456 : explicit StreamModifiersScope(std::ostream* stream)
457 : : stream_(stream), flags_(stream->flags()) {}
458 : ~StreamModifiersScope() { stream_->flags(flags_); }
459 :
460 : private:
461 : std::ostream* stream_;
462 : std::ios::fmtflags flags_;
463 : };
464 :
465 : } // namespace
466 :
467 : // static
468 : void EhFrameDisassembler::DumpDwarfDirectives(std::ostream& stream, // NOLINT
469 : const byte* start,
470 : const byte* end) {
471 : StreamModifiersScope modifiers_scope(&stream);
472 :
473 : EhFrameIterator eh_frame_iterator(start, end);
474 : uint32_t offset_in_procedure = 0;
475 :
476 : while (!eh_frame_iterator.Done()) {
477 : stream << eh_frame_iterator.current_address() << " ";
478 :
479 : byte bytecode = eh_frame_iterator.GetNextByte();
480 :
481 : if (((bytecode >> EhFrameConstants::kLocationMaskSize) & 0xFF) ==
482 : EhFrameConstants::kLocationTag) {
483 : int value = (bytecode & EhFrameConstants::kLocationMask) *
484 : EhFrameConstants::kCodeAlignmentFactor;
485 : offset_in_procedure += value;
486 : stream << "| pc_offset=" << offset_in_procedure << " (delta=" << value
487 : << ")\n";
488 : continue;
489 : }
490 :
491 : if (((bytecode >> EhFrameConstants::kSavedRegisterMaskSize) & 0xFF) ==
492 : EhFrameConstants::kSavedRegisterTag) {
493 : int32_t decoded_offset = eh_frame_iterator.GetNextULeb128();
494 : stream << "| " << DwarfRegisterCodeToString(
495 : bytecode & EhFrameConstants::kLocationMask)
496 : << " saved at base" << std::showpos
497 : << decoded_offset * EhFrameConstants::kDataAlignmentFactor
498 : << std::noshowpos << '\n';
499 : continue;
500 : }
501 :
502 : if (((bytecode >> EhFrameConstants::kFollowInitialRuleMaskSize) & 0xFF) ==
503 : EhFrameConstants::kFollowInitialRuleTag) {
504 : stream << "| " << DwarfRegisterCodeToString(
505 : bytecode & EhFrameConstants::kLocationMask)
506 : << " follows rule in CIE\n";
507 : continue;
508 : }
509 :
510 : switch (static_cast<EhFrameConstants::DwarfOpcodes>(bytecode)) {
511 : case EhFrameConstants::DwarfOpcodes::kOffsetExtendedSf: {
512 : stream << "| "
513 : << DwarfRegisterCodeToString(eh_frame_iterator.GetNextULeb128());
514 : int32_t decoded_offset = eh_frame_iterator.GetNextSLeb128();
515 : stream << " saved at base" << std::showpos
516 : << decoded_offset * EhFrameConstants::kDataAlignmentFactor
517 : << std::noshowpos << '\n';
518 : break;
519 : }
520 : case EhFrameConstants::DwarfOpcodes::kAdvanceLoc1: {
521 : int value = eh_frame_iterator.GetNextByte() *
522 : EhFrameConstants::kCodeAlignmentFactor;
523 : offset_in_procedure += value;
524 : stream << "| pc_offset=" << offset_in_procedure << " (delta=" << value
525 : << ")\n";
526 : break;
527 : }
528 : case EhFrameConstants::DwarfOpcodes::kAdvanceLoc2: {
529 : int value = eh_frame_iterator.GetNextUInt16() *
530 : EhFrameConstants::kCodeAlignmentFactor;
531 : offset_in_procedure += value;
532 : stream << "| pc_offset=" << offset_in_procedure << " (delta=" << value
533 : << ")\n";
534 : break;
535 : }
536 : case EhFrameConstants::DwarfOpcodes::kAdvanceLoc4: {
537 : int value = eh_frame_iterator.GetNextUInt32() *
538 : EhFrameConstants::kCodeAlignmentFactor;
539 : offset_in_procedure += value;
540 : stream << "| pc_offset=" << offset_in_procedure << " (delta=" << value
541 : << ")\n";
542 : break;
543 : }
544 : case EhFrameConstants::DwarfOpcodes::kDefCfa: {
545 : uint32_t base_register = eh_frame_iterator.GetNextULeb128();
546 : uint32_t base_offset = eh_frame_iterator.GetNextULeb128();
547 : stream << "| base_register=" << DwarfRegisterCodeToString(base_register)
548 : << ", base_offset=" << base_offset << '\n';
549 : break;
550 : }
551 : case EhFrameConstants::DwarfOpcodes::kDefCfaOffset: {
552 : stream << "| base_offset=" << eh_frame_iterator.GetNextULeb128()
553 : << '\n';
554 : break;
555 : }
556 : case EhFrameConstants::DwarfOpcodes::kDefCfaRegister: {
557 : stream << "| base_register="
558 : << DwarfRegisterCodeToString(eh_frame_iterator.GetNextULeb128())
559 : << '\n';
560 : break;
561 : }
562 : case EhFrameConstants::DwarfOpcodes::kSameValue: {
563 : stream << "| "
564 : << DwarfRegisterCodeToString(eh_frame_iterator.GetNextULeb128())
565 : << " not modified from previous frame\n";
566 : break;
567 : }
568 : case EhFrameConstants::DwarfOpcodes::kNop:
569 : stream << "| nop\n";
570 : break;
571 : default:
572 : UNREACHABLE();
573 : return;
574 : }
575 : }
576 : }
577 :
578 : void EhFrameDisassembler::DisassembleToStream(std::ostream& stream) { // NOLINT
579 : // The encoded CIE size does not include the size field itself.
580 : const int cie_size =
581 : ReadUnalignedUInt32(reinterpret_cast<Address>(start_)) + kInt32Size;
582 : const int fde_offset = cie_size;
583 :
584 : const byte* cie_directives_start =
585 : start_ + EhFrameConstants::kInitialStateOffsetInCie;
586 : const byte* cie_directives_end = start_ + cie_size;
587 : DCHECK_LE(cie_directives_start, cie_directives_end);
588 :
589 : stream << reinterpret_cast<const void*>(start_) << " .eh_frame: CIE\n";
590 : DumpDwarfDirectives(stream, cie_directives_start, cie_directives_end);
591 :
592 : Address procedure_offset_address =
593 : reinterpret_cast<Address>(start_) + fde_offset +
594 : EhFrameConstants::kProcedureAddressOffsetInFde;
595 : int32_t procedure_offset =
596 : ReadUnalignedValue<int32_t>(procedure_offset_address);
597 :
598 : Address procedure_size_address = reinterpret_cast<Address>(start_) +
599 : fde_offset +
600 : EhFrameConstants::kProcedureSizeOffsetInFde;
601 : uint32_t procedure_size = ReadUnalignedUInt32(procedure_size_address);
602 :
603 : const byte* fde_start = start_ + fde_offset;
604 : stream << reinterpret_cast<const void*>(fde_start) << " .eh_frame: FDE\n"
605 : << reinterpret_cast<const void*>(procedure_offset_address)
606 : << " | procedure_offset=" << procedure_offset << '\n'
607 : << reinterpret_cast<const void*>(procedure_size_address)
608 : << " | procedure_size=" << procedure_size << '\n';
609 :
610 : const int fde_directives_offset = fde_offset + 4 * kInt32Size + 1;
611 :
612 : const byte* fde_directives_start = start_ + fde_directives_offset;
613 : const byte* fde_directives_end = end_ - EhFrameConstants::kEhFrameHdrSize -
614 : EhFrameConstants::kEhFrameTerminatorSize;
615 : DCHECK_LE(fde_directives_start, fde_directives_end);
616 :
617 : DumpDwarfDirectives(stream, fde_directives_start, fde_directives_end);
618 :
619 : const byte* fde_terminator_start = fde_directives_end;
620 : stream << reinterpret_cast<const void*>(fde_terminator_start)
621 : << " .eh_frame: terminator\n";
622 :
623 : const byte* eh_frame_hdr_start =
624 : fde_terminator_start + EhFrameConstants::kEhFrameTerminatorSize;
625 : stream << reinterpret_cast<const void*>(eh_frame_hdr_start)
626 : << " .eh_frame_hdr\n";
627 : }
628 :
629 : #endif
630 :
631 : } // namespace internal
632 183867 : } // namespace v8
|
