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