1// Copyright 2010 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/diagnostics/gdb-jit.h"
6
7#include <iterator>
8#include <map>
9#include <memory>
10#include <vector>
11
12#include "include/v8-callbacks.h"
13#include "src/api/api-inl.h"
14#include "src/base/address-region.h"
15#include "src/base/bits.h"
16#include "src/base/hashmap.h"
17#include "src/base/memory.h"
18#include "src/base/platform/platform.h"
19#include "src/base/platform/wrappers.h"
20#include "src/base/strings.h"
21#include "src/base/vector.h"
22#include "src/execution/frames-inl.h"
23#include "src/execution/frames.h"
24#include "src/handles/global-handles.h"
25#include "src/init/bootstrapper.h"
26#include "src/objects/objects.h"
27#include "src/utils/ostreams.h"
28#include "src/zone/zone-chunk-list.h"
29
30namespace v8 {
31namespace internal {
32namespace GDBJITInterface {
33
34#ifdef ENABLE_GDB_JIT_INTERFACE
35
36#ifdef __APPLE__
37#define __MACH_O
38class MachO;
39class MachOSection;
40using DebugObject = MachO;
41using DebugSection = MachOSection;
42#else
43#define __ELF
44class ELF;
45class ELFSection;
46using DebugObject = ELF;
47using DebugSection = ELFSection;
48#endif
49
50class Writer {
51 public:
52  explicit Writer(DebugObject* debug_object)
53      : debug_object_(debug_object),
54        position_(0),
55        capacity_(1024),
56        buffer_(reinterpret_cast<byte*>(base::Malloc(capacity_))) {}
57
58  ~Writer() { base::Free(buffer_); }
59
60  uintptr_t position() const { return position_; }
61
62  template <typename T>
63  class Slot {
64   public:
65    Slot(Writer* w, uintptr_t offset) : w_(w), offset_(offset) {}
66
67    T* operator->() { return w_->RawSlotAt<T>(offset_); }
68
69    void set(const T& value) {
70      base::WriteUnalignedValue(w_->AddressAt<T>(offset_), value);
71    }
72
73    Slot<T> at(int i) { return Slot<T>(w_, offset_ + sizeof(T) * i); }
74
75   private:
76    Writer* w_;
77    uintptr_t offset_;
78  };
79
80  template <typename T>
81  void Write(const T& val) {
82    Ensure(position_ + sizeof(T));
83    base::WriteUnalignedValue(AddressAt<T>(position_), val);
84    position_ += sizeof(T);
85  }
86
87  template <typename T>
88  Slot<T> SlotAt(uintptr_t offset) {
89    Ensure(offset + sizeof(T));
90    return Slot<T>(this, offset);
91  }
92
93  template <typename T>
94  Slot<T> CreateSlotHere() {
95    return CreateSlotsHere<T>(1);
96  }
97
98  template <typename T>
99  Slot<T> CreateSlotsHere(uint32_t count) {
100    uintptr_t slot_position = position_;
101    position_ += sizeof(T) * count;
102    Ensure(position_);
103    return SlotAt<T>(slot_position);
104  }
105
106  void Ensure(uintptr_t pos) {
107    if (capacity_ < pos) {
108      while (capacity_ < pos) capacity_ *= 2;
109      buffer_ = reinterpret_cast<byte*>(base::Realloc(buffer_, capacity_));
110    }
111  }
112
113  DebugObject* debug_object() { return debug_object_; }
114
115  byte* buffer() { return buffer_; }
116
117  void Align(uintptr_t align) {
118    uintptr_t delta = position_ % align;
119    if (delta == 0) return;
120    uintptr_t padding = align - delta;
121    Ensure(position_ += padding);
122    DCHECK_EQ(position_ % align, 0);
123  }
124
125  void WriteULEB128(uintptr_t value) {
126    do {
127      uint8_t byte = value & 0x7F;
128      value >>= 7;
129      if (value != 0) byte |= 0x80;
130      Write<uint8_t>(byte);
131    } while (value != 0);
132  }
133
134  void WriteSLEB128(intptr_t value) {
135    bool more = true;
136    while (more) {
137      int8_t byte = value & 0x7F;
138      bool byte_sign = byte & 0x40;
139      value >>= 7;
140
141      if ((value == 0 && !byte_sign) || (value == -1 && byte_sign)) {
142        more = false;
143      } else {
144        byte |= 0x80;
145      }
146
147      Write<int8_t>(byte);
148    }
149  }
150
151  void WriteString(const char* str) {
152    do {
153      Write<char>(*str);
154    } while (*str++);
155  }
156
157 private:
158  template <typename T>
159  friend class Slot;
160
161  template <typename T>
162  Address AddressAt(uintptr_t offset) {
163    DCHECK(offset < capacity_ && offset + sizeof(T) <= capacity_);
164    return reinterpret_cast<Address>(&buffer_[offset]);
165  }
166
167  template <typename T>
168  T* RawSlotAt(uintptr_t offset) {
169    DCHECK(offset < capacity_ && offset + sizeof(T) <= capacity_);
170    return reinterpret_cast<T*>(&buffer_[offset]);
171  }
172
173  DebugObject* debug_object_;
174  uintptr_t position_;
175  uintptr_t capacity_;
176  byte* buffer_;
177};
178
179class ELFStringTable;
180
181template <typename THeader>
182class DebugSectionBase : public ZoneObject {
183 public:
184  virtual ~DebugSectionBase() = default;
185
186  virtual void WriteBody(Writer::Slot<THeader> header, Writer* writer) {
187    uintptr_t start = writer->position();
188    if (WriteBodyInternal(writer)) {
189      uintptr_t end = writer->position();
190      header->offset = static_cast<uint32_t>(start);
191#if defined(__MACH_O)
192      header->addr = 0;
193#endif
194      header->size = end - start;
195    }
196  }
197
198  virtual bool WriteBodyInternal(Writer* writer) { return false; }
199
200  using Header = THeader;
201};
202
203struct MachOSectionHeader {
204  char sectname[16];
205  char segname[16];
206#if V8_TARGET_ARCH_IA32
207  uint32_t addr;
208  uint32_t size;
209#else
210  uint64_t addr;
211  uint64_t size;
212#endif
213  uint32_t offset;
214  uint32_t align;
215  uint32_t reloff;
216  uint32_t nreloc;
217  uint32_t flags;
218  uint32_t reserved1;
219  uint32_t reserved2;
220};
221
222class MachOSection : public DebugSectionBase<MachOSectionHeader> {
223 public:
224  enum Type {
225    S_REGULAR = 0x0u,
226    S_ATTR_COALESCED = 0xBu,
227    S_ATTR_SOME_INSTRUCTIONS = 0x400u,
228    S_ATTR_DEBUG = 0x02000000u,
229    S_ATTR_PURE_INSTRUCTIONS = 0x80000000u
230  };
231
232  MachOSection(const char* name, const char* segment, uint32_t align,
233               uint32_t flags)
234      : name_(name), segment_(segment), align_(align), flags_(flags) {
235    if (align_ != 0) {
236      DCHECK(base::bits::IsPowerOfTwo(align));
237      align_ = base::bits::WhichPowerOfTwo(align_);
238    }
239  }
240
241  ~MachOSection() override = default;
242
243  virtual void PopulateHeader(Writer::Slot<Header> header) {
244    header->addr = 0;
245    header->size = 0;
246    header->offset = 0;
247    header->align = align_;
248    header->reloff = 0;
249    header->nreloc = 0;
250    header->flags = flags_;
251    header->reserved1 = 0;
252    header->reserved2 = 0;
253    memset(header->sectname, 0, sizeof(header->sectname));
254    memset(header->segname, 0, sizeof(header->segname));
255    DCHECK(strlen(name_) < sizeof(header->sectname));
256    DCHECK(strlen(segment_) < sizeof(header->segname));
257    strncpy(header->sectname, name_, sizeof(header->sectname));
258    strncpy(header->segname, segment_, sizeof(header->segname));
259  }
260
261 private:
262  const char* name_;
263  const char* segment_;
264  uint32_t align_;
265  uint32_t flags_;
266};
267
268struct ELFSectionHeader {
269  uint32_t name;
270  uint32_t type;
271  uintptr_t flags;
272  uintptr_t address;
273  uintptr_t offset;
274  uintptr_t size;
275  uint32_t link;
276  uint32_t info;
277  uintptr_t alignment;
278  uintptr_t entry_size;
279};
280
281#if defined(__ELF)
282class ELFSection : public DebugSectionBase<ELFSectionHeader> {
283 public:
284  enum Type {
285    TYPE_NULL = 0,
286    TYPE_PROGBITS = 1,
287    TYPE_SYMTAB = 2,
288    TYPE_STRTAB = 3,
289    TYPE_RELA = 4,
290    TYPE_HASH = 5,
291    TYPE_DYNAMIC = 6,
292    TYPE_NOTE = 7,
293    TYPE_NOBITS = 8,
294    TYPE_REL = 9,
295    TYPE_SHLIB = 10,
296    TYPE_DYNSYM = 11,
297    TYPE_LOPROC = 0x70000000,
298    TYPE_X86_64_UNWIND = 0x70000001,
299    TYPE_HIPROC = 0x7FFFFFFF,
300    TYPE_LOUSER = 0x80000000,
301    TYPE_HIUSER = 0xFFFFFFFF
302  };
303
304  enum Flags { FLAG_WRITE = 1, FLAG_ALLOC = 2, FLAG_EXEC = 4 };
305
306  enum SpecialIndexes { INDEX_ABSOLUTE = 0xFFF1 };
307
308  ELFSection(const char* name, Type type, uintptr_t align)
309      : name_(name), type_(type), align_(align) {}
310
311  ~ELFSection() override = default;
312
313  void PopulateHeader(Writer::Slot<Header> header, ELFStringTable* strtab);
314
315  void WriteBody(Writer::Slot<Header> header, Writer* w) override {
316    uintptr_t start = w->position();
317    if (WriteBodyInternal(w)) {
318      uintptr_t end = w->position();
319      header->offset = start;
320      header->size = end - start;
321    }
322  }
323
324  bool WriteBodyInternal(Writer* w) override { return false; }
325
326  uint16_t index() const { return index_; }
327  void set_index(uint16_t index) { index_ = index; }
328
329 protected:
330  virtual void PopulateHeader(Writer::Slot<Header> header) {
331    header->flags = 0;
332    header->address = 0;
333    header->offset = 0;
334    header->size = 0;
335    header->link = 0;
336    header->info = 0;
337    header->entry_size = 0;
338  }
339
340 private:
341  const char* name_;
342  Type type_;
343  uintptr_t align_;
344  uint16_t index_;
345};
346#endif  // defined(__ELF)
347
348#if defined(__MACH_O)
349class MachOTextSection : public MachOSection {
350 public:
351  MachOTextSection(uint32_t align, uintptr_t addr, uintptr_t size)
352      : MachOSection("__text", "__TEXT", align,
353                     MachOSection::S_REGULAR |
354                         MachOSection::S_ATTR_SOME_INSTRUCTIONS |
355                         MachOSection::S_ATTR_PURE_INSTRUCTIONS),
356        addr_(addr),
357        size_(size) {}
358
359 protected:
360  virtual void PopulateHeader(Writer::Slot<Header> header) {
361    MachOSection::PopulateHeader(header);
362    header->addr = addr_;
363    header->size = size_;
364  }
365
366 private:
367  uintptr_t addr_;
368  uintptr_t size_;
369};
370#endif  // defined(__MACH_O)
371
372#if defined(__ELF)
373class FullHeaderELFSection : public ELFSection {
374 public:
375  FullHeaderELFSection(const char* name, Type type, uintptr_t align,
376                       uintptr_t addr, uintptr_t offset, uintptr_t size,
377                       uintptr_t flags)
378      : ELFSection(name, type, align),
379        addr_(addr),
380        offset_(offset),
381        size_(size),
382        flags_(flags) {}
383
384 protected:
385  void PopulateHeader(Writer::Slot<Header> header) override {
386    ELFSection::PopulateHeader(header);
387    header->address = addr_;
388    header->offset = offset_;
389    header->size = size_;
390    header->flags = flags_;
391  }
392
393 private:
394  uintptr_t addr_;
395  uintptr_t offset_;
396  uintptr_t size_;
397  uintptr_t flags_;
398};
399
400class ELFStringTable : public ELFSection {
401 public:
402  explicit ELFStringTable(const char* name)
403      : ELFSection(name, TYPE_STRTAB, 1),
404        writer_(nullptr),
405        offset_(0),
406        size_(0) {}
407
408  uintptr_t Add(const char* str) {
409    if (*str == '\0') return 0;
410
411    uintptr_t offset = size_;
412    WriteString(str);
413    return offset;
414  }
415
416  void AttachWriter(Writer* w) {
417    writer_ = w;
418    offset_ = writer_->position();
419
420    // First entry in the string table should be an empty string.
421    WriteString("");
422  }
423
424  void DetachWriter() { writer_ = nullptr; }
425
426  void WriteBody(Writer::Slot<Header> header, Writer* w) override {
427    DCHECK_NULL(writer_);
428    header->offset = offset_;
429    header->size = size_;
430  }
431
432 private:
433  void WriteString(const char* str) {
434    uintptr_t written = 0;
435    do {
436      writer_->Write(*str);
437      written++;
438    } while (*str++);
439    size_ += written;
440  }
441
442  Writer* writer_;
443
444  uintptr_t offset_;
445  uintptr_t size_;
446};
447
448void ELFSection::PopulateHeader(Writer::Slot<ELFSection::Header> header,
449                                ELFStringTable* strtab) {
450  header->name = static_cast<uint32_t>(strtab->Add(name_));
451  header->type = type_;
452  header->alignment = align_;
453  PopulateHeader(header);
454}
455#endif  // defined(__ELF)
456
457#if defined(__MACH_O)
458class MachO {
459 public:
460  explicit MachO(Zone* zone) : sections_(zone) {}
461
462  size_t AddSection(MachOSection* section) {
463    sections_.push_back(section);
464    return sections_.size() - 1;
465  }
466
467  void Write(Writer* w, uintptr_t code_start, uintptr_t code_size) {
468    Writer::Slot<MachOHeader> header = WriteHeader(w);
469    uintptr_t load_command_start = w->position();
470    Writer::Slot<MachOSegmentCommand> cmd =
471        WriteSegmentCommand(w, code_start, code_size);
472    WriteSections(w, cmd, header, load_command_start);
473  }
474
475 private:
476  struct MachOHeader {
477    uint32_t magic;
478    uint32_t cputype;
479    uint32_t cpusubtype;
480    uint32_t filetype;
481    uint32_t ncmds;
482    uint32_t sizeofcmds;
483    uint32_t flags;
484#if V8_TARGET_ARCH_X64
485    uint32_t reserved;
486#endif
487  };
488
489  struct MachOSegmentCommand {
490    uint32_t cmd;
491    uint32_t cmdsize;
492    char segname[16];
493#if V8_TARGET_ARCH_IA32
494    uint32_t vmaddr;
495    uint32_t vmsize;
496    uint32_t fileoff;
497    uint32_t filesize;
498#else
499    uint64_t vmaddr;
500    uint64_t vmsize;
501    uint64_t fileoff;
502    uint64_t filesize;
503#endif
504    uint32_t maxprot;
505    uint32_t initprot;
506    uint32_t nsects;
507    uint32_t flags;
508  };
509
510  enum MachOLoadCommandCmd {
511    LC_SEGMENT_32 = 0x00000001u,
512    LC_SEGMENT_64 = 0x00000019u
513  };
514
515  Writer::Slot<MachOHeader> WriteHeader(Writer* w) {
516    DCHECK_EQ(w->position(), 0);
517    Writer::Slot<MachOHeader> header = w->CreateSlotHere<MachOHeader>();
518#if V8_TARGET_ARCH_IA32
519    header->magic = 0xFEEDFACEu;
520    header->cputype = 7;     // i386
521    header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
522#elif V8_TARGET_ARCH_X64
523    header->magic = 0xFEEDFACFu;
524    header->cputype = 7 | 0x01000000;  // i386 | 64-bit ABI
525    header->cpusubtype = 3;            // CPU_SUBTYPE_I386_ALL
526    header->reserved = 0;
527#else
528#error Unsupported target architecture.
529#endif
530    header->filetype = 0x1;  // MH_OBJECT
531    header->ncmds = 1;
532    header->sizeofcmds = 0;
533    header->flags = 0;
534    return header;
535  }
536
537  Writer::Slot<MachOSegmentCommand> WriteSegmentCommand(Writer* w,
538                                                        uintptr_t code_start,
539                                                        uintptr_t code_size) {
540    Writer::Slot<MachOSegmentCommand> cmd =
541        w->CreateSlotHere<MachOSegmentCommand>();
542#if V8_TARGET_ARCH_IA32
543    cmd->cmd = LC_SEGMENT_32;
544#else
545    cmd->cmd = LC_SEGMENT_64;
546#endif
547    cmd->vmaddr = code_start;
548    cmd->vmsize = code_size;
549    cmd->fileoff = 0;
550    cmd->filesize = 0;
551    cmd->maxprot = 7;
552    cmd->initprot = 7;
553    cmd->flags = 0;
554    cmd->nsects = static_cast<uint32_t>(sections_.size());
555    memset(cmd->segname, 0, 16);
556    cmd->cmdsize = sizeof(MachOSegmentCommand) +
557                   sizeof(MachOSection::Header) * cmd->nsects;
558    return cmd;
559  }
560
561  void WriteSections(Writer* w, Writer::Slot<MachOSegmentCommand> cmd,
562                     Writer::Slot<MachOHeader> header,
563                     uintptr_t load_command_start) {
564    Writer::Slot<MachOSection::Header> headers =
565        w->CreateSlotsHere<MachOSection::Header>(
566            static_cast<uint32_t>(sections_.size()));
567    cmd->fileoff = w->position();
568    header->sizeofcmds =
569        static_cast<uint32_t>(w->position() - load_command_start);
570    uint32_t index = 0;
571    for (MachOSection* section : sections_) {
572      section->PopulateHeader(headers.at(index));
573      section->WriteBody(headers.at(index), w);
574      index++;
575    }
576    cmd->filesize = w->position() - (uintptr_t)cmd->fileoff;
577  }
578
579  ZoneChunkList<MachOSection*> sections_;
580};
581#endif  // defined(__MACH_O)
582
583#if defined(__ELF)
584class ELF {
585 public:
586  explicit ELF(Zone* zone) : sections_(zone) {
587    sections_.push_back(zone->New<ELFSection>("", ELFSection::TYPE_NULL, 0));
588    sections_.push_back(zone->New<ELFStringTable>(".shstrtab"));
589  }
590
591  void Write(Writer* w) {
592    WriteHeader(w);
593    WriteSectionTable(w);
594    WriteSections(w);
595  }
596
597  ELFSection* SectionAt(uint32_t index) { return *sections_.Find(index); }
598
599  size_t AddSection(ELFSection* section) {
600    sections_.push_back(section);
601    section->set_index(sections_.size() - 1);
602    return sections_.size() - 1;
603  }
604
605 private:
606  struct ELFHeader {
607    uint8_t ident[16];
608    uint16_t type;
609    uint16_t machine;
610    uint32_t version;
611    uintptr_t entry;
612    uintptr_t pht_offset;
613    uintptr_t sht_offset;
614    uint32_t flags;
615    uint16_t header_size;
616    uint16_t pht_entry_size;
617    uint16_t pht_entry_num;
618    uint16_t sht_entry_size;
619    uint16_t sht_entry_num;
620    uint16_t sht_strtab_index;
621  };
622
623  void WriteHeader(Writer* w) {
624    DCHECK_EQ(w->position(), 0);
625    Writer::Slot<ELFHeader> header = w->CreateSlotHere<ELFHeader>();
626#if (V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM)
627    const uint8_t ident[16] = {0x7F, 'E', 'L', 'F', 1, 1, 1, 0,
628                               0,    0,   0,   0,   0, 0, 0, 0};
629#elif V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_64_BIT || \
630    V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN
631    const uint8_t ident[16] = {0x7F, 'E', 'L', 'F', 2, 1, 1, 0,
632                               0,    0,   0,   0,   0, 0, 0, 0};
633#elif V8_TARGET_ARCH_PPC64 && V8_TARGET_BIG_ENDIAN && V8_OS_LINUX
634    const uint8_t ident[16] = {0x7F, 'E', 'L', 'F', 2, 2, 1, 0,
635                               0,    0,   0,   0,   0, 0, 0, 0};
636#elif V8_TARGET_ARCH_S390X
637    const uint8_t ident[16] = {0x7F, 'E', 'L', 'F', 2, 2, 1, 3,
638                               0,    0,   0,   0,   0, 0, 0, 0};
639#elif V8_TARGET_ARCH_S390
640    const uint8_t ident[16] = {0x7F, 'E', 'L', 'F', 1, 2, 1, 3,
641                               0,    0,   0,   0,   0, 0, 0, 0};
642#else
643#error Unsupported target architecture.
644#endif
645    memcpy(header->ident, ident, 16);
646    header->type = 1;
647#if V8_TARGET_ARCH_IA32
648    header->machine = 3;
649#elif V8_TARGET_ARCH_X64
650    // Processor identification value for x64 is 62 as defined in
651    //    System V ABI, AMD64 Supplement
652    //    http://www.x86-64.org/documentation/abi.pdf
653    header->machine = 62;
654#elif V8_TARGET_ARCH_ARM
655    // Set to EM_ARM, defined as 40, in "ARM ELF File Format" at
656    // infocenter.arm.com/help/topic/com.arm.doc.dui0101a/DUI0101A_Elf.pdf
657    header->machine = 40;
658#elif V8_TARGET_ARCH_PPC64 && V8_OS_LINUX
659    // Set to EM_PPC64, defined as 21, in Power ABI,
660    // Join the next 4 lines, omitting the spaces and double-slashes.
661    // https://www-03.ibm.com/technologyconnect/tgcm/TGCMFileServlet.wss/
662    // ABI64BitOpenPOWERv1.1_16July2015_pub.pdf?
663    // id=B81AEC1A37F5DAF185257C3E004E8845&linkid=1n0000&c_t=
664    // c9xw7v5dzsj7gt1ifgf4cjbcnskqptmr
665    header->machine = 21;
666#elif V8_TARGET_ARCH_S390
667    // Processor identification value is 22 (EM_S390) as defined in the ABI:
668    // http://refspecs.linuxbase.org/ELF/zSeries/lzsabi0_s390.html#AEN1691
669    // http://refspecs.linuxbase.org/ELF/zSeries/lzsabi0_zSeries.html#AEN1599
670    header->machine = 22;
671#else
672#error Unsupported target architecture.
673#endif
674    header->version = 1;
675    header->entry = 0;
676    header->pht_offset = 0;
677    header->sht_offset = sizeof(ELFHeader);  // Section table follows header.
678    header->flags = 0;
679    header->header_size = sizeof(ELFHeader);
680    header->pht_entry_size = 0;
681    header->pht_entry_num = 0;
682    header->sht_entry_size = sizeof(ELFSection::Header);
683    header->sht_entry_num = sections_.size();
684    header->sht_strtab_index = 1;
685  }
686
687  void WriteSectionTable(Writer* w) {
688    // Section headers table immediately follows file header.
689    DCHECK(w->position() == sizeof(ELFHeader));
690
691    Writer::Slot<ELFSection::Header> headers =
692        w->CreateSlotsHere<ELFSection::Header>(
693            static_cast<uint32_t>(sections_.size()));
694
695    // String table for section table is the first section.
696    ELFStringTable* strtab = static_cast<ELFStringTable*>(SectionAt(1));
697    strtab->AttachWriter(w);
698    uint32_t index = 0;
699    for (ELFSection* section : sections_) {
700      section->PopulateHeader(headers.at(index), strtab);
701      index++;
702    }
703    strtab->DetachWriter();
704  }
705
706  int SectionHeaderPosition(uint32_t section_index) {
707    return sizeof(ELFHeader) + sizeof(ELFSection::Header) * section_index;
708  }
709
710  void WriteSections(Writer* w) {
711    Writer::Slot<ELFSection::Header> headers =
712        w->SlotAt<ELFSection::Header>(sizeof(ELFHeader));
713
714    uint32_t index = 0;
715    for (ELFSection* section : sections_) {
716      section->WriteBody(headers.at(index), w);
717      index++;
718    }
719  }
720
721  ZoneChunkList<ELFSection*> sections_;
722};
723
724class ELFSymbol {
725 public:
726  enum Type {
727    TYPE_NOTYPE = 0,
728    TYPE_OBJECT = 1,
729    TYPE_FUNC = 2,
730    TYPE_SECTION = 3,
731    TYPE_FILE = 4,
732    TYPE_LOPROC = 13,
733    TYPE_HIPROC = 15
734  };
735
736  enum Binding {
737    BIND_LOCAL = 0,
738    BIND_GLOBAL = 1,
739    BIND_WEAK = 2,
740    BIND_LOPROC = 13,
741    BIND_HIPROC = 15
742  };
743
744  ELFSymbol(const char* name, uintptr_t value, uintptr_t size, Binding binding,
745            Type type, uint16_t section)
746      : name(name),
747        value(value),
748        size(size),
749        info((binding << 4) | type),
750        other(0),
751        section(section) {}
752
753  Binding binding() const { return static_cast<Binding>(info >> 4); }
754#if (V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM || \
755     (V8_TARGET_ARCH_S390 && V8_TARGET_ARCH_32_BIT))
756  struct SerializedLayout {
757    SerializedLayout(uint32_t name, uintptr_t value, uintptr_t size,
758                     Binding binding, Type type, uint16_t section)
759        : name(name),
760          value(value),
761          size(size),
762          info((binding << 4) | type),
763          other(0),
764          section(section) {}
765
766    uint32_t name;
767    uintptr_t value;
768    uintptr_t size;
769    uint8_t info;
770    uint8_t other;
771    uint16_t section;
772  };
773#elif V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_64_BIT || \
774    V8_TARGET_ARCH_PPC64 && V8_OS_LINUX || V8_TARGET_ARCH_S390X
775  struct SerializedLayout {
776    SerializedLayout(uint32_t name, uintptr_t value, uintptr_t size,
777                     Binding binding, Type type, uint16_t section)
778        : name(name),
779          info((binding << 4) | type),
780          other(0),
781          section(section),
782          value(value),
783          size(size) {}
784
785    uint32_t name;
786    uint8_t info;
787    uint8_t other;
788    uint16_t section;
789    uintptr_t value;
790    uintptr_t size;
791  };
792#endif
793
794  void Write(Writer::Slot<SerializedLayout> s, ELFStringTable* t) const {
795    // Convert symbol names from strings to indexes in the string table.
796    s->name = static_cast<uint32_t>(t->Add(name));
797    s->value = value;
798    s->size = size;
799    s->info = info;
800    s->other = other;
801    s->section = section;
802  }
803
804 private:
805  const char* name;
806  uintptr_t value;
807  uintptr_t size;
808  uint8_t info;
809  uint8_t other;
810  uint16_t section;
811};
812
813class ELFSymbolTable : public ELFSection {
814 public:
815  ELFSymbolTable(const char* name, Zone* zone)
816      : ELFSection(name, TYPE_SYMTAB, sizeof(uintptr_t)),
817        locals_(zone),
818        globals_(zone) {}
819
820  void WriteBody(Writer::Slot<Header> header, Writer* w) override {
821    w->Align(header->alignment);
822    size_t total_symbols = locals_.size() + globals_.size() + 1;
823    header->offset = w->position();
824
825    Writer::Slot<ELFSymbol::SerializedLayout> symbols =
826        w->CreateSlotsHere<ELFSymbol::SerializedLayout>(
827            static_cast<uint32_t>(total_symbols));
828
829    header->size = w->position() - header->offset;
830
831    // String table for this symbol table should follow it in the section table.
832    ELFStringTable* strtab =
833        static_cast<ELFStringTable*>(w->debug_object()->SectionAt(index() + 1));
834    strtab->AttachWriter(w);
835    symbols.at(0).set(ELFSymbol::SerializedLayout(
836        0, 0, 0, ELFSymbol::BIND_LOCAL, ELFSymbol::TYPE_NOTYPE, 0));
837    WriteSymbolsList(&locals_, symbols.at(1), strtab);
838    WriteSymbolsList(&globals_,
839                     symbols.at(static_cast<uint32_t>(locals_.size() + 1)),
840                     strtab);
841    strtab->DetachWriter();
842  }
843
844  void Add(const ELFSymbol& symbol) {
845    if (symbol.binding() == ELFSymbol::BIND_LOCAL) {
846      locals_.push_back(symbol);
847    } else {
848      globals_.push_back(symbol);
849    }
850  }
851
852 protected:
853  void PopulateHeader(Writer::Slot<Header> header) override {
854    ELFSection::PopulateHeader(header);
855    // We are assuming that string table will follow symbol table.
856    header->link = index() + 1;
857    header->info = static_cast<uint32_t>(locals_.size() + 1);
858    header->entry_size = sizeof(ELFSymbol::SerializedLayout);
859  }
860
861 private:
862  void WriteSymbolsList(const ZoneChunkList<ELFSymbol>* src,
863                        Writer::Slot<ELFSymbol::SerializedLayout> dst,
864                        ELFStringTable* strtab) {
865    int i = 0;
866    for (const ELFSymbol& symbol : *src) {
867      symbol.Write(dst.at(i++), strtab);
868    }
869  }
870
871  ZoneChunkList<ELFSymbol> locals_;
872  ZoneChunkList<ELFSymbol> globals_;
873};
874#endif  // defined(__ELF)
875
876class LineInfo : public Malloced {
877 public:
878  void SetPosition(intptr_t pc, int pos, bool is_statement) {
879    AddPCInfo(PCInfo(pc, pos, is_statement));
880  }
881
882  struct PCInfo {
883    PCInfo(intptr_t pc, int pos, bool is_statement)
884        : pc_(pc), pos_(pos), is_statement_(is_statement) {}
885
886    intptr_t pc_;
887    int pos_;
888    bool is_statement_;
889  };
890
891  std::vector<PCInfo>* pc_info() { return &pc_info_; }
892
893 private:
894  void AddPCInfo(const PCInfo& pc_info) { pc_info_.push_back(pc_info); }
895
896  std::vector<PCInfo> pc_info_;
897};
898
899class CodeDescription {
900 public:
901#if V8_TARGET_ARCH_X64
902  enum StackState {
903    POST_RBP_PUSH,
904    POST_RBP_SET,
905    POST_RBP_POP,
906    STACK_STATE_MAX
907  };
908#endif
909
910  CodeDescription(const char* name, base::AddressRegion region,
911                  SharedFunctionInfo shared, LineInfo* lineinfo,
912                  bool is_function)
913      : name_(name),
914        shared_info_(shared),
915        lineinfo_(lineinfo),
916        is_function_(is_function),
917        code_region_(region) {}
918
919  const char* name() const { return name_; }
920
921  LineInfo* lineinfo() const { return lineinfo_; }
922
923  bool is_function() const { return is_function_; }
924
925  bool has_scope_info() const { return !shared_info_.is_null(); }
926
927  ScopeInfo scope_info() const {
928    DCHECK(has_scope_info());
929    return shared_info_.scope_info();
930  }
931
932  uintptr_t CodeStart() const { return code_region_.begin(); }
933
934  uintptr_t CodeEnd() const { return code_region_.end(); }
935
936  uintptr_t CodeSize() const { return code_region_.size(); }
937
938  bool has_script() {
939    return !shared_info_.is_null() && shared_info_.script().IsScript();
940  }
941
942  Script script() { return Script::cast(shared_info_.script()); }
943
944  bool IsLineInfoAvailable() { return lineinfo_ != nullptr; }
945
946  base::AddressRegion region() { return code_region_; }
947
948#if V8_TARGET_ARCH_X64
949  uintptr_t GetStackStateStartAddress(StackState state) const {
950    DCHECK(state < STACK_STATE_MAX);
951    return stack_state_start_addresses_[state];
952  }
953
954  void SetStackStateStartAddress(StackState state, uintptr_t addr) {
955    DCHECK(state < STACK_STATE_MAX);
956    stack_state_start_addresses_[state] = addr;
957  }
958#endif
959
960  std::unique_ptr<char[]> GetFilename() {
961    if (!shared_info_.is_null() && script().name().IsString()) {
962      return String::cast(script().name()).ToCString();
963    } else {
964      std::unique_ptr<char[]> result(new char[1]);
965      result[0] = 0;
966      return result;
967    }
968  }
969
970  int GetScriptLineNumber(int pos) {
971    if (!shared_info_.is_null()) {
972      return script().GetLineNumber(pos) + 1;
973    } else {
974      return 0;
975    }
976  }
977
978 private:
979  const char* name_;
980  SharedFunctionInfo shared_info_;
981  LineInfo* lineinfo_;
982  bool is_function_;
983  base::AddressRegion code_region_;
984#if V8_TARGET_ARCH_X64
985  uintptr_t stack_state_start_addresses_[STACK_STATE_MAX];
986#endif
987};
988
989#if defined(__ELF)
990static void CreateSymbolsTable(CodeDescription* desc, Zone* zone, ELF* elf,
991                               size_t text_section_index) {
992  ELFSymbolTable* symtab = zone->New<ELFSymbolTable>(".symtab", zone);
993  ELFStringTable* strtab = zone->New<ELFStringTable>(".strtab");
994
995  // Symbol table should be followed by the linked string table.
996  elf->AddSection(symtab);
997  elf->AddSection(strtab);
998
999  symtab->Add(ELFSymbol("V8 Code", 0, 0, ELFSymbol::BIND_LOCAL,
1000                        ELFSymbol::TYPE_FILE, ELFSection::INDEX_ABSOLUTE));
1001
1002  symtab->Add(ELFSymbol(desc->name(), 0, desc->CodeSize(),
1003                        ELFSymbol::BIND_GLOBAL, ELFSymbol::TYPE_FUNC,
1004                        text_section_index));
1005}
1006#endif  // defined(__ELF)
1007
1008class DebugInfoSection : public DebugSection {
1009 public:
1010  explicit DebugInfoSection(CodeDescription* desc)
1011#if defined(__ELF)
1012      : ELFSection(".debug_info", TYPE_PROGBITS, 1),
1013#else
1014      : MachOSection("__debug_info", "__DWARF", 1,
1015                     MachOSection::S_REGULAR | MachOSection::S_ATTR_DEBUG),
1016#endif
1017        desc_(desc) {
1018  }
1019
1020  // DWARF2 standard
1021  enum DWARF2LocationOp {
1022    DW_OP_reg0 = 0x50,
1023    DW_OP_reg1 = 0x51,
1024    DW_OP_reg2 = 0x52,
1025    DW_OP_reg3 = 0x53,
1026    DW_OP_reg4 = 0x54,
1027    DW_OP_reg5 = 0x55,
1028    DW_OP_reg6 = 0x56,
1029    DW_OP_reg7 = 0x57,
1030    DW_OP_reg8 = 0x58,
1031    DW_OP_reg9 = 0x59,
1032    DW_OP_reg10 = 0x5A,
1033    DW_OP_reg11 = 0x5B,
1034    DW_OP_reg12 = 0x5C,
1035    DW_OP_reg13 = 0x5D,
1036    DW_OP_reg14 = 0x5E,
1037    DW_OP_reg15 = 0x5F,
1038    DW_OP_reg16 = 0x60,
1039    DW_OP_reg17 = 0x61,
1040    DW_OP_reg18 = 0x62,
1041    DW_OP_reg19 = 0x63,
1042    DW_OP_reg20 = 0x64,
1043    DW_OP_reg21 = 0x65,
1044    DW_OP_reg22 = 0x66,
1045    DW_OP_reg23 = 0x67,
1046    DW_OP_reg24 = 0x68,
1047    DW_OP_reg25 = 0x69,
1048    DW_OP_reg26 = 0x6A,
1049    DW_OP_reg27 = 0x6B,
1050    DW_OP_reg28 = 0x6C,
1051    DW_OP_reg29 = 0x6D,
1052    DW_OP_reg30 = 0x6E,
1053    DW_OP_reg31 = 0x6F,
1054    DW_OP_fbreg = 0x91  // 1 param: SLEB128 offset
1055  };
1056
1057  enum DWARF2Encoding { DW_ATE_ADDRESS = 0x1, DW_ATE_SIGNED = 0x5 };
1058
1059  bool WriteBodyInternal(Writer* w) override {
1060    uintptr_t cu_start = w->position();
1061    Writer::Slot<uint32_t> size = w->CreateSlotHere<uint32_t>();
1062    uintptr_t start = w->position();
1063    w->Write<uint16_t>(2);  // DWARF version.
1064    w->Write<uint32_t>(0);  // Abbreviation table offset.
1065    w->Write<uint8_t>(sizeof(intptr_t));
1066
1067    w->WriteULEB128(1);  // Abbreviation code.
1068    w->WriteString(desc_->GetFilename().get());
1069    w->Write<intptr_t>(desc_->CodeStart());
1070    w->Write<intptr_t>(desc_->CodeStart() + desc_->CodeSize());
1071    w->Write<uint32_t>(0);
1072
1073    uint32_t ty_offset = static_cast<uint32_t>(w->position() - cu_start);
1074    w->WriteULEB128(3);
1075    w->Write<uint8_t>(kSystemPointerSize);
1076    w->WriteString("v8value");
1077
1078    if (desc_->has_scope_info()) {
1079      ScopeInfo scope = desc_->scope_info();
1080      w->WriteULEB128(2);
1081      w->WriteString(desc_->name());
1082      w->Write<intptr_t>(desc_->CodeStart());
1083      w->Write<intptr_t>(desc_->CodeStart() + desc_->CodeSize());
1084      Writer::Slot<uint32_t> fb_block_size = w->CreateSlotHere<uint32_t>();
1085      uintptr_t fb_block_start = w->position();
1086#if V8_TARGET_ARCH_IA32
1087      w->Write<uint8_t>(DW_OP_reg5);  // The frame pointer's here on ia32
1088#elif V8_TARGET_ARCH_X64
1089      w->Write<uint8_t>(DW_OP_reg6);  // and here on x64.
1090#elif V8_TARGET_ARCH_ARM
1091      UNIMPLEMENTED();
1092#elif V8_TARGET_ARCH_MIPS
1093      UNIMPLEMENTED();
1094#elif V8_TARGET_ARCH_MIPS64
1095      UNIMPLEMENTED();
1096#elif V8_TARGET_ARCH_LOONG64
1097      UNIMPLEMENTED();
1098#elif V8_TARGET_ARCH_PPC64 && V8_OS_LINUX
1099      w->Write<uint8_t>(DW_OP_reg31);  // The frame pointer is here on PPC64.
1100#elif V8_TARGET_ARCH_S390
1101      w->Write<uint8_t>(DW_OP_reg11);  // The frame pointer's here on S390.
1102#else
1103#error Unsupported target architecture.
1104#endif
1105      fb_block_size.set(static_cast<uint32_t>(w->position() - fb_block_start));
1106
1107      int params = scope.ParameterCount();
1108      int context_slots = scope.ContextLocalCount();
1109      // The real slot ID is internal_slots + context_slot_id.
1110      int internal_slots = scope.ContextHeaderLength();
1111      int current_abbreviation = 4;
1112
1113      for (int param = 0; param < params; ++param) {
1114        w->WriteULEB128(current_abbreviation++);
1115        w->WriteString("param");
1116        w->Write(std::to_string(param).c_str());
1117        w->Write<uint32_t>(ty_offset);
1118        Writer::Slot<uint32_t> block_size = w->CreateSlotHere<uint32_t>();
1119        uintptr_t block_start = w->position();
1120        w->Write<uint8_t>(DW_OP_fbreg);
1121        w->WriteSLEB128(StandardFrameConstants::kFixedFrameSizeAboveFp +
1122                        kSystemPointerSize * (params - param - 1));
1123        block_size.set(static_cast<uint32_t>(w->position() - block_start));
1124      }
1125
1126      // See contexts.h for more information.
1127      DCHECK(internal_slots == 2 || internal_slots == 3);
1128      DCHECK_EQ(Context::SCOPE_INFO_INDEX, 0);
1129      DCHECK_EQ(Context::PREVIOUS_INDEX, 1);
1130      DCHECK_EQ(Context::EXTENSION_INDEX, 2);
1131      w->WriteULEB128(current_abbreviation++);
1132      w->WriteString(".scope_info");
1133      w->WriteULEB128(current_abbreviation++);
1134      w->WriteString(".previous");
1135      if (internal_slots == 3) {
1136        w->WriteULEB128(current_abbreviation++);
1137        w->WriteString(".extension");
1138      }
1139
1140      for (int context_slot = 0; context_slot < context_slots; ++context_slot) {
1141        w->WriteULEB128(current_abbreviation++);
1142        w->WriteString("context_slot");
1143        w->Write(std::to_string(context_slot + internal_slots).c_str());
1144      }
1145
1146      {
1147        w->WriteULEB128(current_abbreviation++);
1148        w->WriteString("__function");
1149        w->Write<uint32_t>(ty_offset);
1150        Writer::Slot<uint32_t> block_size = w->CreateSlotHere<uint32_t>();
1151        uintptr_t block_start = w->position();
1152        w->Write<uint8_t>(DW_OP_fbreg);
1153        w->WriteSLEB128(StandardFrameConstants::kFunctionOffset);
1154        block_size.set(static_cast<uint32_t>(w->position() - block_start));
1155      }
1156
1157      {
1158        w->WriteULEB128(current_abbreviation++);
1159        w->WriteString("__context");
1160        w->Write<uint32_t>(ty_offset);
1161        Writer::Slot<uint32_t> block_size = w->CreateSlotHere<uint32_t>();
1162        uintptr_t block_start = w->position();
1163        w->Write<uint8_t>(DW_OP_fbreg);
1164        w->WriteSLEB128(StandardFrameConstants::kContextOffset);
1165        block_size.set(static_cast<uint32_t>(w->position() - block_start));
1166      }
1167
1168      w->WriteULEB128(0);  // Terminate the sub program.
1169    }
1170
1171    w->WriteULEB128(0);  // Terminate the compile unit.
1172    size.set(static_cast<uint32_t>(w->position() - start));
1173    return true;
1174  }
1175
1176 private:
1177  CodeDescription* desc_;
1178};
1179
1180class DebugAbbrevSection : public DebugSection {
1181 public:
1182  explicit DebugAbbrevSection(CodeDescription* desc)
1183#ifdef __ELF
1184      : ELFSection(".debug_abbrev", TYPE_PROGBITS, 1),
1185#else
1186      : MachOSection("__debug_abbrev", "__DWARF", 1,
1187                     MachOSection::S_REGULAR | MachOSection::S_ATTR_DEBUG),
1188#endif
1189        desc_(desc) {
1190  }
1191
1192  // DWARF2 standard, figure 14.
1193  enum DWARF2Tags {
1194    DW_TAG_FORMAL_PARAMETER = 0x05,
1195    DW_TAG_POINTER_TYPE = 0xF,
1196    DW_TAG_COMPILE_UNIT = 0x11,
1197    DW_TAG_STRUCTURE_TYPE = 0x13,
1198    DW_TAG_BASE_TYPE = 0x24,
1199    DW_TAG_SUBPROGRAM = 0x2E,
1200    DW_TAG_VARIABLE = 0x34
1201  };
1202
1203  // DWARF2 standard, figure 16.
1204  enum DWARF2ChildrenDetermination { DW_CHILDREN_NO = 0, DW_CHILDREN_YES = 1 };
1205
1206  // DWARF standard, figure 17.
1207  enum DWARF2Attribute {
1208    DW_AT_LOCATION = 0x2,
1209    DW_AT_NAME = 0x3,
1210    DW_AT_BYTE_SIZE = 0xB,
1211    DW_AT_STMT_LIST = 0x10,
1212    DW_AT_LOW_PC = 0x11,
1213    DW_AT_HIGH_PC = 0x12,
1214    DW_AT_ENCODING = 0x3E,
1215    DW_AT_FRAME_BASE = 0x40,
1216    DW_AT_TYPE = 0x49
1217  };
1218
1219  // DWARF2 standard, figure 19.
1220  enum DWARF2AttributeForm {
1221    DW_FORM_ADDR = 0x1,
1222    DW_FORM_BLOCK4 = 0x4,
1223    DW_FORM_STRING = 0x8,
1224    DW_FORM_DATA4 = 0x6,
1225    DW_FORM_BLOCK = 0x9,
1226    DW_FORM_DATA1 = 0xB,
1227    DW_FORM_FLAG = 0xC,
1228    DW_FORM_REF4 = 0x13
1229  };
1230
1231  void WriteVariableAbbreviation(Writer* w, int abbreviation_code,
1232                                 bool has_value, bool is_parameter) {
1233    w->WriteULEB128(abbreviation_code);
1234    w->WriteULEB128(is_parameter ? DW_TAG_FORMAL_PARAMETER : DW_TAG_VARIABLE);
1235    w->Write<uint8_t>(DW_CHILDREN_NO);
1236    w->WriteULEB128(DW_AT_NAME);
1237    w->WriteULEB128(DW_FORM_STRING);
1238    if (has_value) {
1239      w->WriteULEB128(DW_AT_TYPE);
1240      w->WriteULEB128(DW_FORM_REF4);
1241      w->WriteULEB128(DW_AT_LOCATION);
1242      w->WriteULEB128(DW_FORM_BLOCK4);
1243    }
1244    w->WriteULEB128(0);
1245    w->WriteULEB128(0);
1246  }
1247
1248  bool WriteBodyInternal(Writer* w) override {
1249    int current_abbreviation = 1;
1250    bool extra_info = desc_->has_scope_info();
1251    DCHECK(desc_->IsLineInfoAvailable());
1252    w->WriteULEB128(current_abbreviation++);
1253    w->WriteULEB128(DW_TAG_COMPILE_UNIT);
1254    w->Write<uint8_t>(extra_info ? DW_CHILDREN_YES : DW_CHILDREN_NO);
1255    w->WriteULEB128(DW_AT_NAME);
1256    w->WriteULEB128(DW_FORM_STRING);
1257    w->WriteULEB128(DW_AT_LOW_PC);
1258    w->WriteULEB128(DW_FORM_ADDR);
1259    w->WriteULEB128(DW_AT_HIGH_PC);
1260    w->WriteULEB128(DW_FORM_ADDR);
1261    w->WriteULEB128(DW_AT_STMT_LIST);
1262    w->WriteULEB128(DW_FORM_DATA4);
1263    w->WriteULEB128(0);
1264    w->WriteULEB128(0);
1265
1266    if (extra_info) {
1267      ScopeInfo scope = desc_->scope_info();
1268      int params = scope.ParameterCount();
1269      int context_slots = scope.ContextLocalCount();
1270      // The real slot ID is internal_slots + context_slot_id.
1271      int internal_slots = Context::MIN_CONTEXT_SLOTS;
1272      // Total children is params + context_slots + internal_slots + 2
1273      // (__function and __context).
1274
1275      // The extra duplication below seems to be necessary to keep
1276      // gdb from getting upset on OSX.
1277      w->WriteULEB128(current_abbreviation++);  // Abbreviation code.
1278      w->WriteULEB128(DW_TAG_SUBPROGRAM);
1279      w->Write<uint8_t>(DW_CHILDREN_YES);
1280      w->WriteULEB128(DW_AT_NAME);
1281      w->WriteULEB128(DW_FORM_STRING);
1282      w->WriteULEB128(DW_AT_LOW_PC);
1283      w->WriteULEB128(DW_FORM_ADDR);
1284      w->WriteULEB128(DW_AT_HIGH_PC);
1285      w->WriteULEB128(DW_FORM_ADDR);
1286      w->WriteULEB128(DW_AT_FRAME_BASE);
1287      w->WriteULEB128(DW_FORM_BLOCK4);
1288      w->WriteULEB128(0);
1289      w->WriteULEB128(0);
1290
1291      w->WriteULEB128(current_abbreviation++);
1292      w->WriteULEB128(DW_TAG_STRUCTURE_TYPE);
1293      w->Write<uint8_t>(DW_CHILDREN_NO);
1294      w->WriteULEB128(DW_AT_BYTE_SIZE);
1295      w->WriteULEB128(DW_FORM_DATA1);
1296      w->WriteULEB128(DW_AT_NAME);
1297      w->WriteULEB128(DW_FORM_STRING);
1298      w->WriteULEB128(0);
1299      w->WriteULEB128(0);
1300
1301      for (int param = 0; param < params; ++param) {
1302        WriteVariableAbbreviation(w, current_abbreviation++, true, true);
1303      }
1304
1305      for (int internal_slot = 0; internal_slot < internal_slots;
1306           ++internal_slot) {
1307        WriteVariableAbbreviation(w, current_abbreviation++, false, false);
1308      }
1309
1310      for (int context_slot = 0; context_slot < context_slots; ++context_slot) {
1311        WriteVariableAbbreviation(w, current_abbreviation++, false, false);
1312      }
1313
1314      // The function.
1315      WriteVariableAbbreviation(w, current_abbreviation++, true, false);
1316
1317      // The context.
1318      WriteVariableAbbreviation(w, current_abbreviation++, true, false);
1319
1320      w->WriteULEB128(0);  // Terminate the sibling list.
1321    }
1322
1323    w->WriteULEB128(0);  // Terminate the table.
1324    return true;
1325  }
1326
1327 private:
1328  CodeDescription* desc_;
1329};
1330
1331class DebugLineSection : public DebugSection {
1332 public:
1333  explicit DebugLineSection(CodeDescription* desc)
1334#ifdef __ELF
1335      : ELFSection(".debug_line", TYPE_PROGBITS, 1),
1336#else
1337      : MachOSection("__debug_line", "__DWARF", 1,
1338                     MachOSection::S_REGULAR | MachOSection::S_ATTR_DEBUG),
1339#endif
1340        desc_(desc) {
1341  }
1342
1343  // DWARF2 standard, figure 34.
1344  enum DWARF2Opcodes {
1345    DW_LNS_COPY = 1,
1346    DW_LNS_ADVANCE_PC = 2,
1347    DW_LNS_ADVANCE_LINE = 3,
1348    DW_LNS_SET_FILE = 4,
1349    DW_LNS_SET_COLUMN = 5,
1350    DW_LNS_NEGATE_STMT = 6
1351  };
1352
1353  // DWARF2 standard, figure 35.
1354  enum DWARF2ExtendedOpcode {
1355    DW_LNE_END_SEQUENCE = 1,
1356    DW_LNE_SET_ADDRESS = 2,
1357    DW_LNE_DEFINE_FILE = 3
1358  };
1359
1360  bool WriteBodyInternal(Writer* w) override {
1361    // Write prologue.
1362    Writer::Slot<uint32_t> total_length = w->CreateSlotHere<uint32_t>();
1363    uintptr_t start = w->position();
1364
1365    // Used for special opcodes
1366    const int8_t line_base = 1;
1367    const uint8_t line_range = 7;
1368    const int8_t max_line_incr = (line_base + line_range - 1);
1369    const uint8_t opcode_base = DW_LNS_NEGATE_STMT + 1;
1370
1371    w->Write<uint16_t>(2);  // Field version.
1372    Writer::Slot<uint32_t> prologue_length = w->CreateSlotHere<uint32_t>();
1373    uintptr_t prologue_start = w->position();
1374    w->Write<uint8_t>(1);            // Field minimum_instruction_length.
1375    w->Write<uint8_t>(1);            // Field default_is_stmt.
1376    w->Write<int8_t>(line_base);     // Field line_base.
1377    w->Write<uint8_t>(line_range);   // Field line_range.
1378    w->Write<uint8_t>(opcode_base);  // Field opcode_base.
1379    w->Write<uint8_t>(0);            // DW_LNS_COPY operands count.
1380    w->Write<uint8_t>(1);            // DW_LNS_ADVANCE_PC operands count.
1381    w->Write<uint8_t>(1);            // DW_LNS_ADVANCE_LINE operands count.
1382    w->Write<uint8_t>(1);            // DW_LNS_SET_FILE operands count.
1383    w->Write<uint8_t>(1);            // DW_LNS_SET_COLUMN operands count.
1384    w->Write<uint8_t>(0);            // DW_LNS_NEGATE_STMT operands count.
1385    w->Write<uint8_t>(0);            // Empty include_directories sequence.
1386    w->WriteString(desc_->GetFilename().get());  // File name.
1387    w->WriteULEB128(0);                          // Current directory.
1388    w->WriteULEB128(0);                          // Unknown modification time.
1389    w->WriteULEB128(0);                          // Unknown file size.
1390    w->Write<uint8_t>(0);
1391    prologue_length.set(static_cast<uint32_t>(w->position() - prologue_start));
1392
1393    WriteExtendedOpcode(w, DW_LNE_SET_ADDRESS, sizeof(intptr_t));
1394    w->Write<intptr_t>(desc_->CodeStart());
1395    w->Write<uint8_t>(DW_LNS_COPY);
1396
1397    intptr_t pc = 0;
1398    intptr_t line = 1;
1399    bool is_statement = true;
1400
1401    std::vector<LineInfo::PCInfo>* pc_info = desc_->lineinfo()->pc_info();
1402    std::sort(pc_info->begin(), pc_info->end(), &ComparePCInfo);
1403
1404    for (size_t i = 0; i < pc_info->size(); i++) {
1405      LineInfo::PCInfo* info = &pc_info->at(i);
1406      DCHECK(info->pc_ >= pc);
1407
1408      // Reduce bloating in the debug line table by removing duplicate line
1409      // entries (per DWARF2 standard).
1410      intptr_t new_line = desc_->GetScriptLineNumber(info->pos_);
1411      if (new_line == line) {
1412        continue;
1413      }
1414
1415      // Mark statement boundaries.  For a better debugging experience, mark
1416      // the last pc address in the function as a statement (e.g. "}"), so that
1417      // a user can see the result of the last line executed in the function,
1418      // should control reach the end.
1419      if ((i + 1) == pc_info->size()) {
1420        if (!is_statement) {
1421          w->Write<uint8_t>(DW_LNS_NEGATE_STMT);
1422        }
1423      } else if (is_statement != info->is_statement_) {
1424        w->Write<uint8_t>(DW_LNS_NEGATE_STMT);
1425        is_statement = !is_statement;
1426      }
1427
1428      // Generate special opcodes, if possible.  This results in more compact
1429      // debug line tables.  See the DWARF 2.0 standard to learn more about
1430      // special opcodes.
1431      uintptr_t pc_diff = info->pc_ - pc;
1432      intptr_t line_diff = new_line - line;
1433
1434      // Compute special opcode (see DWARF 2.0 standard)
1435      intptr_t special_opcode =
1436          (line_diff - line_base) + (line_range * pc_diff) + opcode_base;
1437
1438      // If special_opcode is less than or equal to 255, it can be used as a
1439      // special opcode.  If line_diff is larger than the max line increment
1440      // allowed for a special opcode, or if line_diff is less than the minimum
1441      // line that can be added to the line register (i.e. line_base), then
1442      // special_opcode can't be used.
1443      if ((special_opcode >= opcode_base) && (special_opcode <= 255) &&
1444          (line_diff <= max_line_incr) && (line_diff >= line_base)) {
1445        w->Write<uint8_t>(special_opcode);
1446      } else {
1447        w->Write<uint8_t>(DW_LNS_ADVANCE_PC);
1448        w->WriteSLEB128(pc_diff);
1449        w->Write<uint8_t>(DW_LNS_ADVANCE_LINE);
1450        w->WriteSLEB128(line_diff);
1451        w->Write<uint8_t>(DW_LNS_COPY);
1452      }
1453
1454      // Increment the pc and line operands.
1455      pc += pc_diff;
1456      line += line_diff;
1457    }
1458    // Advance the pc to the end of the routine, since the end sequence opcode
1459    // requires this.
1460    w->Write<uint8_t>(DW_LNS_ADVANCE_PC);
1461    w->WriteSLEB128(desc_->CodeSize() - pc);
1462    WriteExtendedOpcode(w, DW_LNE_END_SEQUENCE, 0);
1463    total_length.set(static_cast<uint32_t>(w->position() - start));
1464    return true;
1465  }
1466
1467 private:
1468  void WriteExtendedOpcode(Writer* w, DWARF2ExtendedOpcode op,
1469                           size_t operands_size) {
1470    w->Write<uint8_t>(0);
1471    w->WriteULEB128(operands_size + 1);
1472    w->Write<uint8_t>(op);
1473  }
1474
1475  static bool ComparePCInfo(const LineInfo::PCInfo& a,
1476                            const LineInfo::PCInfo& b) {
1477    if (a.pc_ == b.pc_) {
1478      if (a.is_statement_ != b.is_statement_) {
1479        return !b.is_statement_;
1480      }
1481      return false;
1482    }
1483    return a.pc_ < b.pc_;
1484  }
1485
1486  CodeDescription* desc_;
1487};
1488
1489#if V8_TARGET_ARCH_X64
1490
1491class UnwindInfoSection : public DebugSection {
1492 public:
1493  explicit UnwindInfoSection(CodeDescription* desc);
1494  bool WriteBodyInternal(Writer* w) override;
1495
1496  int WriteCIE(Writer* w);
1497  void WriteFDE(Writer* w, int);
1498
1499  void WriteFDEStateOnEntry(Writer* w);
1500  void WriteFDEStateAfterRBPPush(Writer* w);
1501  void WriteFDEStateAfterRBPSet(Writer* w);
1502  void WriteFDEStateAfterRBPPop(Writer* w);
1503
1504  void WriteLength(Writer* w, Writer::Slot<uint32_t>* length_slot,
1505                   int initial_position);
1506
1507 private:
1508  CodeDescription* desc_;
1509
1510  // DWARF3 Specification, Table 7.23
1511  enum CFIInstructions {
1512    DW_CFA_ADVANCE_LOC = 0x40,
1513    DW_CFA_OFFSET = 0x80,
1514    DW_CFA_RESTORE = 0xC0,
1515    DW_CFA_NOP = 0x00,
1516    DW_CFA_SET_LOC = 0x01,
1517    DW_CFA_ADVANCE_LOC1 = 0x02,
1518    DW_CFA_ADVANCE_LOC2 = 0x03,
1519    DW_CFA_ADVANCE_LOC4 = 0x04,
1520    DW_CFA_OFFSET_EXTENDED = 0x05,
1521    DW_CFA_RESTORE_EXTENDED = 0x06,
1522    DW_CFA_UNDEFINED = 0x07,
1523    DW_CFA_SAME_VALUE = 0x08,
1524    DW_CFA_REGISTER = 0x09,
1525    DW_CFA_REMEMBER_STATE = 0x0A,
1526    DW_CFA_RESTORE_STATE = 0x0B,
1527    DW_CFA_DEF_CFA = 0x0C,
1528    DW_CFA_DEF_CFA_REGISTER = 0x0D,
1529    DW_CFA_DEF_CFA_OFFSET = 0x0E,
1530
1531    DW_CFA_DEF_CFA_EXPRESSION = 0x0F,
1532    DW_CFA_EXPRESSION = 0x10,
1533    DW_CFA_OFFSET_EXTENDED_SF = 0x11,
1534    DW_CFA_DEF_CFA_SF = 0x12,
1535    DW_CFA_DEF_CFA_OFFSET_SF = 0x13,
1536    DW_CFA_VAL_OFFSET = 0x14,
1537    DW_CFA_VAL_OFFSET_SF = 0x15,
1538    DW_CFA_VAL_EXPRESSION = 0x16
1539  };
1540
1541  // System V ABI, AMD64 Supplement, Version 0.99.5, Figure 3.36
1542  enum RegisterMapping {
1543    // Only the relevant ones have been added to reduce clutter.
1544    AMD64_RBP = 6,
1545    AMD64_RSP = 7,
1546    AMD64_RA = 16
1547  };
1548
1549  enum CFIConstants {
1550    CIE_ID = 0,
1551    CIE_VERSION = 1,
1552    CODE_ALIGN_FACTOR = 1,
1553    DATA_ALIGN_FACTOR = 1,
1554    RETURN_ADDRESS_REGISTER = AMD64_RA
1555  };
1556};
1557
1558void UnwindInfoSection::WriteLength(Writer* w,
1559                                    Writer::Slot<uint32_t>* length_slot,
1560                                    int initial_position) {
1561  uint32_t align = (w->position() - initial_position) % kSystemPointerSize;
1562
1563  if (align != 0) {
1564    for (uint32_t i = 0; i < (kSystemPointerSize - align); i++) {
1565      w->Write<uint8_t>(DW_CFA_NOP);
1566    }
1567  }
1568
1569  DCHECK_EQ((w->position() - initial_position) % kSystemPointerSize, 0);
1570  length_slot->set(static_cast<uint32_t>(w->position() - initial_position));
1571}
1572
1573UnwindInfoSection::UnwindInfoSection(CodeDescription* desc)
1574#ifdef __ELF
1575    : ELFSection(".eh_frame", TYPE_X86_64_UNWIND, 1),
1576#else
1577    : MachOSection("__eh_frame", "__TEXT", sizeof(uintptr_t),
1578                   MachOSection::S_REGULAR),
1579#endif
1580      desc_(desc) {
1581}
1582
1583int UnwindInfoSection::WriteCIE(Writer* w) {
1584  Writer::Slot<uint32_t> cie_length_slot = w->CreateSlotHere<uint32_t>();
1585  uint32_t cie_position = static_cast<uint32_t>(w->position());
1586
1587  // Write out the CIE header. Currently no 'common instructions' are
1588  // emitted onto the CIE; every FDE has its own set of instructions.
1589
1590  w->Write<uint32_t>(CIE_ID);
1591  w->Write<uint8_t>(CIE_VERSION);
1592  w->Write<uint8_t>(0);  // Null augmentation string.
1593  w->WriteSLEB128(CODE_ALIGN_FACTOR);
1594  w->WriteSLEB128(DATA_ALIGN_FACTOR);
1595  w->Write<uint8_t>(RETURN_ADDRESS_REGISTER);
1596
1597  WriteLength(w, &cie_length_slot, cie_position);
1598
1599  return cie_position;
1600}
1601
1602void UnwindInfoSection::WriteFDE(Writer* w, int cie_position) {
1603  // The only FDE for this function. The CFA is the current RBP.
1604  Writer::Slot<uint32_t> fde_length_slot = w->CreateSlotHere<uint32_t>();
1605  int fde_position = static_cast<uint32_t>(w->position());
1606  w->Write<int32_t>(fde_position - cie_position + 4);
1607
1608  w->Write<uintptr_t>(desc_->CodeStart());
1609  w->Write<uintptr_t>(desc_->CodeSize());
1610
1611  WriteFDEStateOnEntry(w);
1612  WriteFDEStateAfterRBPPush(w);
1613  WriteFDEStateAfterRBPSet(w);
1614  WriteFDEStateAfterRBPPop(w);
1615
1616  WriteLength(w, &fde_length_slot, fde_position);
1617}
1618
1619void UnwindInfoSection::WriteFDEStateOnEntry(Writer* w) {
1620  // The first state, just after the control has been transferred to the the
1621  // function.
1622
1623  // RBP for this function will be the value of RSP after pushing the RBP
1624  // for the previous function. The previous RBP has not been pushed yet.
1625  w->Write<uint8_t>(DW_CFA_DEF_CFA_SF);
1626  w->WriteULEB128(AMD64_RSP);
1627  w->WriteSLEB128(-kSystemPointerSize);
1628
1629  // The RA is stored at location CFA + kCallerPCOffset. This is an invariant,
1630  // and hence omitted from the next states.
1631  w->Write<uint8_t>(DW_CFA_OFFSET_EXTENDED);
1632  w->WriteULEB128(AMD64_RA);
1633  w->WriteSLEB128(StandardFrameConstants::kCallerPCOffset);
1634
1635  // The RBP of the previous function is still in RBP.
1636  w->Write<uint8_t>(DW_CFA_SAME_VALUE);
1637  w->WriteULEB128(AMD64_RBP);
1638
1639  // Last location described by this entry.
1640  w->Write<uint8_t>(DW_CFA_SET_LOC);
1641  w->Write<uint64_t>(
1642      desc_->GetStackStateStartAddress(CodeDescription::POST_RBP_PUSH));
1643}
1644
1645void UnwindInfoSection::WriteFDEStateAfterRBPPush(Writer* w) {
1646  // The second state, just after RBP has been pushed.
1647
1648  // RBP / CFA for this function is now the current RSP, so just set the
1649  // offset from the previous rule (from -8) to 0.
1650  w->Write<uint8_t>(DW_CFA_DEF_CFA_OFFSET);
1651  w->WriteULEB128(0);
1652
1653  // The previous RBP is stored at CFA + kCallerFPOffset. This is an invariant
1654  // in this and the next state, and hence omitted in the next state.
1655  w->Write<uint8_t>(DW_CFA_OFFSET_EXTENDED);
1656  w->WriteULEB128(AMD64_RBP);
1657  w->WriteSLEB128(StandardFrameConstants::kCallerFPOffset);
1658
1659  // Last location described by this entry.
1660  w->Write<uint8_t>(DW_CFA_SET_LOC);
1661  w->Write<uint64_t>(
1662      desc_->GetStackStateStartAddress(CodeDescription::POST_RBP_SET));
1663}
1664
1665void UnwindInfoSection::WriteFDEStateAfterRBPSet(Writer* w) {
1666  // The third state, after the RBP has been set.
1667
1668  // The CFA can now directly be set to RBP.
1669  w->Write<uint8_t>(DW_CFA_DEF_CFA);
1670  w->WriteULEB128(AMD64_RBP);
1671  w->WriteULEB128(0);
1672
1673  // Last location described by this entry.
1674  w->Write<uint8_t>(DW_CFA_SET_LOC);
1675  w->Write<uint64_t>(
1676      desc_->GetStackStateStartAddress(CodeDescription::POST_RBP_POP));
1677}
1678
1679void UnwindInfoSection::WriteFDEStateAfterRBPPop(Writer* w) {
1680  // The fourth (final) state. The RBP has been popped (just before issuing a
1681  // return).
1682
1683  // The CFA can is now calculated in the same way as in the first state.
1684  w->Write<uint8_t>(DW_CFA_DEF_CFA_SF);
1685  w->WriteULEB128(AMD64_RSP);
1686  w->WriteSLEB128(-kSystemPointerSize);
1687
1688  // The RBP
1689  w->Write<uint8_t>(DW_CFA_OFFSET_EXTENDED);
1690  w->WriteULEB128(AMD64_RBP);
1691  w->WriteSLEB128(StandardFrameConstants::kCallerFPOffset);
1692
1693  // Last location described by this entry.
1694  w->Write<uint8_t>(DW_CFA_SET_LOC);
1695  w->Write<uint64_t>(desc_->CodeEnd());
1696}
1697
1698bool UnwindInfoSection::WriteBodyInternal(Writer* w) {
1699  uint32_t cie_position = WriteCIE(w);
1700  WriteFDE(w, cie_position);
1701  return true;
1702}
1703
1704#endif  // V8_TARGET_ARCH_X64
1705
1706static void CreateDWARFSections(CodeDescription* desc, Zone* zone,
1707                                DebugObject* obj) {
1708  if (desc->IsLineInfoAvailable()) {
1709    obj->AddSection(zone->New<DebugInfoSection>(desc));
1710    obj->AddSection(zone->New<DebugAbbrevSection>(desc));
1711    obj->AddSection(zone->New<DebugLineSection>(desc));
1712  }
1713#if V8_TARGET_ARCH_X64
1714  obj->AddSection(zone->New<UnwindInfoSection>(desc));
1715#endif
1716}
1717
1718// -------------------------------------------------------------------
1719// Binary GDB JIT Interface as described in
1720//   http://sourceware.org/gdb/onlinedocs/gdb/Declarations.html
1721extern "C" {
1722enum JITAction { JIT_NOACTION = 0, JIT_REGISTER_FN, JIT_UNREGISTER_FN };
1723
1724struct JITCodeEntry {
1725  JITCodeEntry* next_;
1726  JITCodeEntry* prev_;
1727  Address symfile_addr_;
1728  uint64_t symfile_size_;
1729};
1730
1731struct JITDescriptor {
1732  uint32_t version_;
1733  uint32_t action_flag_;
1734  JITCodeEntry* relevant_entry_;
1735  JITCodeEntry* first_entry_;
1736};
1737
1738// GDB will place breakpoint into this function.
1739// To prevent GCC from inlining or removing it we place noinline attribute
1740// and inline assembler statement inside.
1741void __attribute__((noinline)) __jit_debug_register_code() { __asm__(""); }
1742
1743// GDB will inspect contents of this descriptor.
1744// Static initialization is necessary to prevent GDB from seeing
1745// uninitialized descriptor.
1746JITDescriptor __jit_debug_descriptor = {1, 0, nullptr, nullptr};
1747
1748#ifdef OBJECT_PRINT
1749void __gdb_print_v8_object(Object object) {
1750  StdoutStream os;
1751  object.Print(os);
1752  os << std::flush;
1753}
1754#endif
1755}
1756
1757static JITCodeEntry* CreateCodeEntry(Address symfile_addr,
1758                                     uintptr_t symfile_size) {
1759  JITCodeEntry* entry = static_cast<JITCodeEntry*>(
1760      base::Malloc(sizeof(JITCodeEntry) + symfile_size));
1761
1762  entry->symfile_addr_ = reinterpret_cast<Address>(entry + 1);
1763  entry->symfile_size_ = symfile_size;
1764  MemCopy(reinterpret_cast<void*>(entry->symfile_addr_),
1765          reinterpret_cast<void*>(symfile_addr), symfile_size);
1766
1767  entry->prev_ = entry->next_ = nullptr;
1768
1769  return entry;
1770}
1771
1772static void DestroyCodeEntry(JITCodeEntry* entry) { base::Free(entry); }
1773
1774static void RegisterCodeEntry(JITCodeEntry* entry) {
1775  entry->next_ = __jit_debug_descriptor.first_entry_;
1776  if (entry->next_ != nullptr) entry->next_->prev_ = entry;
1777  __jit_debug_descriptor.first_entry_ = __jit_debug_descriptor.relevant_entry_ =
1778      entry;
1779
1780  __jit_debug_descriptor.action_flag_ = JIT_REGISTER_FN;
1781  __jit_debug_register_code();
1782}
1783
1784static void UnregisterCodeEntry(JITCodeEntry* entry) {
1785  if (entry->prev_ != nullptr) {
1786    entry->prev_->next_ = entry->next_;
1787  } else {
1788    __jit_debug_descriptor.first_entry_ = entry->next_;
1789  }
1790
1791  if (entry->next_ != nullptr) {
1792    entry->next_->prev_ = entry->prev_;
1793  }
1794
1795  __jit_debug_descriptor.relevant_entry_ = entry;
1796  __jit_debug_descriptor.action_flag_ = JIT_UNREGISTER_FN;
1797  __jit_debug_register_code();
1798}
1799
1800static JITCodeEntry* CreateELFObject(CodeDescription* desc, Isolate* isolate) {
1801#ifdef __MACH_O
1802  Zone zone(isolate->allocator(), ZONE_NAME);
1803  MachO mach_o(&zone);
1804  Writer w(&mach_o);
1805
1806  const uint32_t code_alignment = static_cast<uint32_t>(kCodeAlignment);
1807  static_assert(code_alignment == kCodeAlignment,
1808                "Unsupported code alignment value");
1809  mach_o.AddSection(zone.New<MachOTextSection>(
1810      code_alignment, desc->CodeStart(), desc->CodeSize()));
1811
1812  CreateDWARFSections(desc, &zone, &mach_o);
1813
1814  mach_o.Write(&w, desc->CodeStart(), desc->CodeSize());
1815#else
1816  Zone zone(isolate->allocator(), ZONE_NAME);
1817  ELF elf(&zone);
1818  Writer w(&elf);
1819
1820  size_t text_section_index = elf.AddSection(zone.New<FullHeaderELFSection>(
1821      ".text", ELFSection::TYPE_NOBITS, kCodeAlignment, desc->CodeStart(), 0,
1822      desc->CodeSize(), ELFSection::FLAG_ALLOC | ELFSection::FLAG_EXEC));
1823
1824  CreateSymbolsTable(desc, &zone, &elf, text_section_index);
1825
1826  CreateDWARFSections(desc, &zone, &elf);
1827
1828  elf.Write(&w);
1829#endif
1830
1831  return CreateCodeEntry(reinterpret_cast<Address>(w.buffer()), w.position());
1832}
1833
1834// Like base::AddressRegion::StartAddressLess but also compares |end| when
1835// |begin| is equal.
1836struct AddressRegionLess {
1837  bool operator()(const base::AddressRegion& a,
1838                  const base::AddressRegion& b) const {
1839    if (a.begin() == b.begin()) return a.end() < b.end();
1840    return a.begin() < b.begin();
1841  }
1842};
1843
1844using CodeMap = std::map<base::AddressRegion, JITCodeEntry*, AddressRegionLess>;
1845
1846static CodeMap* GetCodeMap() {
1847  // TODO(jgruber): Don't leak.
1848  static CodeMap* code_map = nullptr;
1849  if (code_map == nullptr) code_map = new CodeMap();
1850  return code_map;
1851}
1852
1853static uint32_t HashCodeAddress(Address addr) {
1854  static const uintptr_t kGoldenRatio = 2654435761u;
1855  return static_cast<uint32_t>((addr >> kCodeAlignmentBits) * kGoldenRatio);
1856}
1857
1858static base::HashMap* GetLineMap() {
1859  static base::HashMap* line_map = nullptr;
1860  if (line_map == nullptr) {
1861    line_map = new base::HashMap();
1862  }
1863  return line_map;
1864}
1865
1866static void PutLineInfo(Address addr, LineInfo* info) {
1867  base::HashMap* line_map = GetLineMap();
1868  base::HashMap::Entry* e = line_map->LookupOrInsert(
1869      reinterpret_cast<void*>(addr), HashCodeAddress(addr));
1870  if (e->value != nullptr) delete static_cast<LineInfo*>(e->value);
1871  e->value = info;
1872}
1873
1874static LineInfo* GetLineInfo(Address addr) {
1875  void* value = GetLineMap()->Remove(reinterpret_cast<void*>(addr),
1876                                     HashCodeAddress(addr));
1877  return static_cast<LineInfo*>(value);
1878}
1879
1880static void AddUnwindInfo(CodeDescription* desc) {
1881#if V8_TARGET_ARCH_X64
1882  if (desc->is_function()) {
1883    // To avoid propagating unwinding information through
1884    // compilation pipeline we use an approximation.
1885    // For most use cases this should not affect usability.
1886    static const int kFramePointerPushOffset = 1;
1887    static const int kFramePointerSetOffset = 4;
1888    static const int kFramePointerPopOffset = -3;
1889
1890    uintptr_t frame_pointer_push_address =
1891        desc->CodeStart() + kFramePointerPushOffset;
1892
1893    uintptr_t frame_pointer_set_address =
1894        desc->CodeStart() + kFramePointerSetOffset;
1895
1896    uintptr_t frame_pointer_pop_address =
1897        desc->CodeEnd() + kFramePointerPopOffset;
1898
1899    desc->SetStackStateStartAddress(CodeDescription::POST_RBP_PUSH,
1900                                    frame_pointer_push_address);
1901    desc->SetStackStateStartAddress(CodeDescription::POST_RBP_SET,
1902                                    frame_pointer_set_address);
1903    desc->SetStackStateStartAddress(CodeDescription::POST_RBP_POP,
1904                                    frame_pointer_pop_address);
1905  } else {
1906    desc->SetStackStateStartAddress(CodeDescription::POST_RBP_PUSH,
1907                                    desc->CodeStart());
1908    desc->SetStackStateStartAddress(CodeDescription::POST_RBP_SET,
1909                                    desc->CodeStart());
1910    desc->SetStackStateStartAddress(CodeDescription::POST_RBP_POP,
1911                                    desc->CodeEnd());
1912  }
1913#endif  // V8_TARGET_ARCH_X64
1914}
1915
1916static base::LazyMutex mutex = LAZY_MUTEX_INITIALIZER;
1917
1918static base::Optional<std::pair<CodeMap::iterator, CodeMap::iterator>>
1919GetOverlappingRegions(CodeMap* map, const base::AddressRegion region) {
1920  DCHECK_LT(region.begin(), region.end());
1921
1922  if (map->empty()) return {};
1923
1924  // Find the first overlapping entry.
1925
1926  // If successful, points to the first element not less than `region`. The
1927  // returned iterator has the key in `first` and the value in `second`.
1928  auto it = map->lower_bound(region);
1929  auto start_it = it;
1930
1931  if (it == map->end()) {
1932    start_it = map->begin();
1933    // Find the first overlapping entry.
1934    for (; start_it != map->end(); ++start_it) {
1935      if (start_it->first.end() > region.begin()) {
1936        break;
1937      }
1938    }
1939  } else if (it != map->begin()) {
1940    for (--it; it != map->begin(); --it) {
1941      if ((*it).first.end() <= region.begin()) break;
1942      start_it = it;
1943    }
1944    if (it == map->begin() && it->first.end() > region.begin()) {
1945      start_it = it;
1946    }
1947  }
1948
1949  if (start_it == map->end()) {
1950    return {};
1951  }
1952
1953  // Find the first non-overlapping entry after `region`.
1954
1955  const auto end_it = map->lower_bound({region.end(), 0});
1956
1957  // Return a range containing intersecting regions.
1958
1959  if (std::distance(start_it, end_it) < 1)
1960    return {};  // No overlapping entries.
1961
1962  return {{start_it, end_it}};
1963}
1964
1965// Remove entries from the map that intersect the given address region,
1966// and deregister them from GDB.
1967static void RemoveJITCodeEntries(CodeMap* map,
1968                                 const base::AddressRegion region) {
1969  if (auto overlap = GetOverlappingRegions(map, region)) {
1970    auto start_it = overlap->first;
1971    auto end_it = overlap->second;
1972    for (auto it = start_it; it != end_it; it++) {
1973      JITCodeEntry* old_entry = (*it).second;
1974      UnregisterCodeEntry(old_entry);
1975      DestroyCodeEntry(old_entry);
1976    }
1977
1978    map->erase(start_it, end_it);
1979  }
1980}
1981
1982// Insert the entry into the map and register it with GDB.
1983static void AddJITCodeEntry(CodeMap* map, const base::AddressRegion region,
1984                            JITCodeEntry* entry, bool dump_if_enabled,
1985                            const char* name_hint) {
1986#if defined(DEBUG) && !V8_OS_WIN
1987  static int file_num = 0;
1988  if (FLAG_gdbjit_dump && dump_if_enabled) {
1989    static const int kMaxFileNameSize = 64;
1990    char file_name[64];
1991
1992    SNPrintF(base::Vector<char>(file_name, kMaxFileNameSize),
1993             "/tmp/elfdump%s%d.o", (name_hint != nullptr) ? name_hint : "",
1994             file_num++);
1995    WriteBytes(file_name, reinterpret_cast<byte*>(entry->symfile_addr_),
1996               static_cast<int>(entry->symfile_size_));
1997  }
1998#endif
1999
2000  auto result = map->emplace(region, entry);
2001  DCHECK(result.second);  // Insertion happened.
2002  USE(result);
2003
2004  RegisterCodeEntry(entry);
2005}
2006
2007static void AddCode(const char* name, base::AddressRegion region,
2008                    SharedFunctionInfo shared, LineInfo* lineinfo,
2009                    Isolate* isolate, bool is_function) {
2010  DisallowGarbageCollection no_gc;
2011  CodeDescription code_desc(name, region, shared, lineinfo, is_function);
2012
2013  CodeMap* code_map = GetCodeMap();
2014  RemoveJITCodeEntries(code_map, region);
2015
2016  if (!FLAG_gdbjit_full && !code_desc.IsLineInfoAvailable()) {
2017    delete lineinfo;
2018    return;
2019  }
2020
2021  AddUnwindInfo(&code_desc);
2022  JITCodeEntry* entry = CreateELFObject(&code_desc, isolate);
2023
2024  delete lineinfo;
2025
2026  const char* name_hint = nullptr;
2027  bool should_dump = false;
2028  if (FLAG_gdbjit_dump) {
2029    if (strlen(FLAG_gdbjit_dump_filter) == 0) {
2030      name_hint = name;
2031      should_dump = true;
2032    } else if (name != nullptr) {
2033      name_hint = strstr(name, FLAG_gdbjit_dump_filter);
2034      should_dump = (name_hint != nullptr);
2035    }
2036  }
2037  AddJITCodeEntry(code_map, region, entry, should_dump, name_hint);
2038}
2039
2040void EventHandler(const v8::JitCodeEvent* event) {
2041  if (!FLAG_gdbjit) return;
2042  if ((event->code_type != v8::JitCodeEvent::JIT_CODE) &&
2043      (event->code_type != v8::JitCodeEvent::WASM_CODE)) {
2044    return;
2045  }
2046  base::MutexGuard lock_guard(mutex.Pointer());
2047  switch (event->type) {
2048    case v8::JitCodeEvent::CODE_ADDED: {
2049      Address addr = reinterpret_cast<Address>(event->code_start);
2050      LineInfo* lineinfo = GetLineInfo(addr);
2051      std::string event_name(event->name.str, event->name.len);
2052      // It's called UnboundScript in the API but it's a SharedFunctionInfo.
2053      SharedFunctionInfo shared = event->script.IsEmpty()
2054                                      ? SharedFunctionInfo()
2055                                      : *Utils::OpenHandle(*event->script);
2056      Isolate* isolate = reinterpret_cast<Isolate*>(event->isolate);
2057      bool is_function = false;
2058      // TODO(zhin): See if we can use event->code_type to determine
2059      // is_function, the difference currently is that JIT_CODE is SparkPlug,
2060      // TurboProp, TurboFan, whereas CodeKindIsOptimizedJSFunction is only
2061      // TurboProp and TurboFan. is_function is used for AddUnwindInfo, and the
2062      // prologue that SP generates probably matches that of TP/TF, so we can
2063      // use event->code_type here instead of finding the Code.
2064      // TODO(zhin): Rename is_function to be more accurate.
2065      if (event->code_type == v8::JitCodeEvent::JIT_CODE) {
2066        Code code = isolate->heap()->GcSafeFindCodeForInnerPointer(addr);
2067        is_function = CodeKindIsOptimizedJSFunction(code.kind());
2068      }
2069      AddCode(event_name.c_str(), {addr, event->code_len}, shared, lineinfo,
2070              isolate, is_function);
2071      break;
2072    }
2073    case v8::JitCodeEvent::CODE_MOVED:
2074      // Enabling the GDB JIT interface should disable code compaction.
2075      UNREACHABLE();
2076    case v8::JitCodeEvent::CODE_REMOVED:
2077      // Do nothing.  Instead, adding code causes eviction of any entry whose
2078      // address range intersects the address range of the added code.
2079      break;
2080    case v8::JitCodeEvent::CODE_ADD_LINE_POS_INFO: {
2081      LineInfo* line_info = reinterpret_cast<LineInfo*>(event->user_data);
2082      line_info->SetPosition(static_cast<intptr_t>(event->line_info.offset),
2083                             static_cast<int>(event->line_info.pos),
2084                             event->line_info.position_type ==
2085                                 v8::JitCodeEvent::STATEMENT_POSITION);
2086      break;
2087    }
2088    case v8::JitCodeEvent::CODE_START_LINE_INFO_RECORDING: {
2089      v8::JitCodeEvent* mutable_event = const_cast<v8::JitCodeEvent*>(event);
2090      mutable_event->user_data = new LineInfo();
2091      break;
2092    }
2093    case v8::JitCodeEvent::CODE_END_LINE_INFO_RECORDING: {
2094      LineInfo* line_info = reinterpret_cast<LineInfo*>(event->user_data);
2095      PutLineInfo(reinterpret_cast<Address>(event->code_start), line_info);
2096      break;
2097    }
2098  }
2099}
2100
2101void AddRegionForTesting(const base::AddressRegion region) {
2102  // For testing purposes we don't care about JITCodeEntry, pass nullptr.
2103  auto result = GetCodeMap()->emplace(region, nullptr);
2104  DCHECK(result.second);  // Insertion happened.
2105  USE(result);
2106}
2107
2108void ClearCodeMapForTesting() { GetCodeMap()->clear(); }
2109
2110size_t NumOverlapEntriesForTesting(const base::AddressRegion region) {
2111  if (auto overlaps = GetOverlappingRegions(GetCodeMap(), region)) {
2112    return std::distance(overlaps->first, overlaps->second);
2113  }
2114  return 0;
2115}
2116
2117#endif
2118}  // namespace GDBJITInterface
2119}  // namespace internal
2120}  // namespace v8
2121
2122#undef __MACH_O
2123#undef __ELF
2124