V8 API Reference, 7.2.502.16 (for Deno 0.2.4)
eh-frame.cc
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 void EhFrameWriter::WriteEmptyEhFrame(std::ostream& stream) { // NOLINT
56  stream.put(EhFrameConstants::kEhFrameHdrVersion);
57 
58  // .eh_frame pointer encoding specifier.
59  stream.put(EhFrameConstants::kSData4 | EhFrameConstants::kPcRel);
60 
61  // Lookup table size encoding.
62  stream.put(EhFrameConstants::kUData4);
63 
64  // Lookup table entries encoding.
65  stream.put(EhFrameConstants::kSData4 | EhFrameConstants::kDataRel);
66 
67  // Dummy pointers and 0 entries in the lookup table.
68  char dummy_data[EhFrameConstants::kEhFrameHdrSize - 4] = {0};
69  stream.write(&dummy_data[0], sizeof(dummy_data));
70 }
71 
72 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  eh_frame_buffer_(zone) {}
79 
80 void EhFrameWriter::Initialize() {
81  DCHECK_EQ(writer_state_, InternalState::kUndefined);
82  eh_frame_buffer_.reserve(128);
83  writer_state_ = InternalState::kInitialized;
84  WriteCie();
85  WriteFdeHeader();
86 }
87 
88 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  WriteSLeb128(EhFrameConstants::kCodeAlignmentFactor);
108  WriteSLeb128(EhFrameConstants::kDataAlignmentFactor);
109 
110  WriteReturnAddressRegisterCode();
111 
112  // Augmentation data.
113  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  WriteInitialStateInCie();
123 
124  WritePaddingToAlignedSize(eh_frame_offset() - record_start_offset);
125 
126  int record_end_offset = eh_frame_offset();
127  int encoded_cie_size = record_end_offset - record_start_offset;
128  cie_size_ = record_end_offset - size_offset;
129 
130  // Patch the size of the CIE now that we know it.
131  PatchInt32(size_offset, encoded_cie_size);
132 }
133 
134 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  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 }
155 
156 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  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  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  WriteInt32(-(eh_frame_size - cie_size_));
233 
234  DCHECK_EQ(eh_frame_offset() - eh_frame_size,
235  EhFrameConstants::kEhFrameHdrSize);
236 }
237 
238 void EhFrameWriter::WritePaddingToAlignedSize(int unpadded_size) {
239  DCHECK_EQ(writer_state_, InternalState::kInitialized);
240  DCHECK_GE(unpadded_size, 0);
241 
242  int padding_size = RoundUp(unpadded_size, kPointerSize) - unpadded_size;
243 
244  byte nop = static_cast<byte>(EhFrameConstants::DwarfOpcodes::kNop);
245  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 }
249 
250 void EhFrameWriter::AdvanceLocation(int pc_offset) {
251  DCHECK_EQ(writer_state_, InternalState::kInitialized);
252  DCHECK_GE(pc_offset, last_pc_offset_);
253  uint32_t delta = pc_offset - last_pc_offset_;
254 
255  DCHECK_EQ(delta % EhFrameConstants::kCodeAlignmentFactor, 0u);
256  uint32_t factored_delta = delta / EhFrameConstants::kCodeAlignmentFactor;
257 
258  if (factored_delta <= EhFrameConstants::kLocationMask) {
259  WriteByte((EhFrameConstants::kLocationTag
260  << EhFrameConstants::kLocationMaskSize) |
261  (factored_delta & EhFrameConstants::kLocationMask));
262  } else if (factored_delta <= kMaxUInt8) {
263  WriteOpcode(EhFrameConstants::DwarfOpcodes::kAdvanceLoc1);
264  WriteByte(factored_delta);
265  } 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  last_pc_offset_ = pc_offset;
274 }
275 
276 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  WriteULeb128(base_offset);
281  base_offset_ = base_offset;
282 }
283 
284 void EhFrameWriter::SetBaseAddressRegister(Register base_register) {
285  DCHECK_EQ(writer_state_, InternalState::kInitialized);
286  int code = RegisterToDwarfCode(base_register);
287  WriteOpcode(EhFrameConstants::DwarfOpcodes::kDefCfaRegister);
288  WriteULeb128(code);
289  base_register_ = base_register;
290 }
291 
292 void EhFrameWriter::SetBaseAddressRegisterAndOffset(Register base_register,
293  int base_offset) {
294  DCHECK_EQ(writer_state_, InternalState::kInitialized);
295  DCHECK_GE(base_offset, 0);
296  int code = RegisterToDwarfCode(base_register);
297  WriteOpcode(EhFrameConstants::DwarfOpcodes::kDefCfa);
298  WriteULeb128(code);
299  WriteULeb128(base_offset);
300  base_offset_ = base_offset;
301  base_register_ = base_register;
302 }
303 
304 void EhFrameWriter::RecordRegisterSavedToStack(int register_code, int offset) {
305  DCHECK_EQ(writer_state_, InternalState::kInitialized);
306  DCHECK_EQ(offset % EhFrameConstants::kDataAlignmentFactor, 0);
307  int factored_offset = offset / EhFrameConstants::kDataAlignmentFactor;
308  if (factored_offset >= 0) {
309  DCHECK_LE(register_code, EhFrameConstants::kSavedRegisterMask);
310  WriteByte((EhFrameConstants::kSavedRegisterTag
311  << EhFrameConstants::kSavedRegisterMaskSize) |
312  (register_code & EhFrameConstants::kSavedRegisterMask));
313  WriteULeb128(factored_offset);
314  } else {
315  WriteOpcode(EhFrameConstants::DwarfOpcodes::kOffsetExtendedSf);
316  WriteULeb128(register_code);
317  WriteSLeb128(factored_offset);
318  }
319 }
320 
321 void EhFrameWriter::RecordRegisterNotModified(Register name) {
322  DCHECK_EQ(writer_state_, InternalState::kInitialized);
323  WriteOpcode(EhFrameConstants::DwarfOpcodes::kSameValue);
324  WriteULeb128(RegisterToDwarfCode(name));
325 }
326 
327 void EhFrameWriter::RecordRegisterFollowsInitialRule(Register name) {
328  DCHECK_EQ(writer_state_, InternalState::kInitialized);
329  int code = RegisterToDwarfCode(name);
330  DCHECK_LE(code, EhFrameConstants::kFollowInitialRuleMask);
331  WriteByte((EhFrameConstants::kFollowInitialRuleTag
332  << EhFrameConstants::kFollowInitialRuleMaskSize) |
333  (code & EhFrameConstants::kFollowInitialRuleMask));
334 }
335 
336 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  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  int encoded_fde_size = eh_frame_offset() - fde_offset() - kInt32Size;
346  PatchInt32(fde_offset(), encoded_fde_size);
347 
348  // Write size and offset to procedure.
349  PatchInt32(GetProcedureAddressOffset(),
350  -(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  WriteEhFrameHdr(code_size);
358 
359  writer_state_ = InternalState::kFinalized;
360 }
361 
362 void EhFrameWriter::GetEhFrame(CodeDesc* desc) {
363  DCHECK_EQ(writer_state_, InternalState::kFinalized);
364  desc->unwinding_info_size = static_cast<int>(eh_frame_buffer_.size());
365  desc->unwinding_info = eh_frame_buffer_.data();
366 }
367 
368 void EhFrameWriter::WriteULeb128(uint32_t value) {
369  do {
370  byte chunk = value & 0x7F;
371  value >>= 7;
372  if (value != 0) chunk |= 0x80;
373  WriteByte(chunk);
374  } while (value != 0);
375 }
376 
377 void EhFrameWriter::WriteSLeb128(int32_t value) {
378  static const int kSignBitMask = 0x40;
379  bool done;
380  do {
381  byte chunk = value & 0x7F;
382  value >>= 7;
383  done = ((value == 0) && ((chunk & kSignBitMask) == 0)) ||
384  ((value == -1) && ((chunk & kSignBitMask) != 0));
385  if (!done) chunk |= 0x80;
386  WriteByte(chunk);
387  } while (!done);
388 }
389 
390 uint32_t EhFrameIterator::GetNextULeb128() {
391  int size = 0;
392  uint32_t result = DecodeULeb128(next_, &size);
393  DCHECK_LE(next_ + size, end_);
394  next_ += size;
395  return result;
396 }
397 
398 int32_t EhFrameIterator::GetNextSLeb128() {
399  int size = 0;
400  int32_t result = DecodeSLeb128(next_, &size);
401  DCHECK_LE(next_ + size, end_);
402  next_ += size;
403  return result;
404 }
405 
406 // static
407 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  do {
414  DCHECK_LT(shift, 8 * static_cast<int>(sizeof(result)));
415  result |= (*current & 0x7F) << shift;
416  shift += 7;
417  } while (*current++ >= 128);
418 
419  DCHECK_NOT_NULL(encoded_size);
420  *encoded_size = static_cast<int>(current - encoded);
421 
422  return result;
423 }
424 
425 // static
426 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  do {
435  chunk = *current++;
436  DCHECK_LT(shift, 8 * static_cast<int>(sizeof(result)));
437  result |= (chunk & 0x7F) << shift;
438  shift += 7;
439  } while (chunk >= 128);
440 
441  // Sign extend the result if the last chunk has the sign bit set.
442  if (chunk & kSignBitMask) result |= (~0ull) << shift;
443 
444  DCHECK_NOT_NULL(encoded_size);
445  *encoded_size = static_cast<int>(current - encoded);
446 
447  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 } // namespace v8
v8
Definition: libplatform.h:13
uint32_t