Introduce x87 port

src/gdb-jit.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifdef ENABLE_GDB_JIT_INTERFACE
 #include "v8.h"
 #include "gdb-jit.h"
 
 #include "bootstrapper.h"
 #include "compiler.h"
@@ skipping 176 matching lines @@
     return false;
   }
 
   typedef THeader Header;
 };
 
 
 struct MachOSectionHeader {
   char sectname[16];
   char segname[16];
-#if V8_TARGET_ARCH_IA32
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
   uint32_t addr;
   uint32_t size;
 #else
   uint64_t addr;
   uint64_t size;
 #endif
   uint32_t offset;
   uint32_t align;
   uint32_t reloff;
   uint32_t nreloc;
@@ skipping 296 matching lines @@
     uint32_t flags;
 #if V8_TARGET_ARCH_X64
     uint32_t reserved;
 #endif
   };
 
   struct MachOSegmentCommand {
     uint32_t cmd;
     uint32_t cmdsize;
     char segname[16];
-#if V8_TARGET_ARCH_IA32
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
     uint32_t vmaddr;
     uint32_t vmsize;
     uint32_t fileoff;
     uint32_t filesize;
 #else
     uint64_t vmaddr;
     uint64_t vmsize;
     uint64_t fileoff;
     uint64_t filesize;
 #endif
     uint32_t maxprot;
     uint32_t initprot;
     uint32_t nsects;
     uint32_t flags;
   };
 
   enum MachOLoadCommandCmd {
     LC_SEGMENT_32 = 0x00000001u,
     LC_SEGMENT_64 = 0x00000019u
   };
 
 
   Writer::Slot<MachOHeader> WriteHeader(Writer* w) {
     ASSERT(w->position() == 0);
     Writer::Slot<MachOHeader> header = w->CreateSlotHere<MachOHeader>();
-#if V8_TARGET_ARCH_IA32
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
     header->magic = 0xFEEDFACEu;
     header->cputype = 7;  // i386
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
 #elif V8_TARGET_ARCH_X64
     header->magic = 0xFEEDFACFu;
     header->cputype = 7 | 0x01000000;  // i386 | 64-bit ABI
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
     header->reserved = 0;
 #else
 #error Unsupported target architecture.
 #endif
     header->filetype = 0x1;  // MH_OBJECT
     header->ncmds = 1;
     header->sizeofcmds = 0;
     header->flags = 0;
     return header;
   }
 
 
   Writer::Slot<MachOSegmentCommand> WriteSegmentCommand(Writer* w,
                                                         uintptr_t code_start,
                                                         uintptr_t code_size) {
     Writer::Slot<MachOSegmentCommand> cmd =
         w->CreateSlotHere<MachOSegmentCommand>();
-#if V8_TARGET_ARCH_IA32
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
     cmd->cmd = LC_SEGMENT_32;
 #else
     cmd->cmd = LC_SEGMENT_64;
 #endif
     cmd->vmaddr = code_start;
     cmd->vmsize = code_size;
     cmd->fileoff = 0;
     cmd->filesize = 0;
     cmd->maxprot = 7;
     cmd->initprot = 7;
@@ skipping 66 matching lines @@
     uint16_t pht_entry_num;
     uint16_t sht_entry_size;
     uint16_t sht_entry_num;
     uint16_t sht_strtab_index;
   };
 
 
   void WriteHeader(Writer* w) {
     ASSERT(w->position() == 0);
     Writer::Slot<ELFHeader> header = w->CreateSlotHere<ELFHeader>();
-#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_X87
     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 #elif V8_TARGET_ARCH_X64
     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 #else
 #error Unsupported target architecture.
 #endif
     OS::MemCopy(header->ident, ident, 16);
     header->type = 1;
-#if V8_TARGET_ARCH_IA32
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
     header->machine = 3;
 #elif V8_TARGET_ARCH_X64
     // Processor identification value for x64 is 62 as defined in
     //    System V ABI, AMD64 Supplement
     //    http://www.x86-64.org/documentation/abi.pdf
     header->machine = 62;
 #elif V8_TARGET_ARCH_ARM
     // Set to EM_ARM, defined as 40, in "ARM ELF File Format" at
     // infocenter.arm.com/help/topic/com.arm.doc.dui0101a/DUI0101A_Elf.pdf
     header->machine = 40;
@@ skipping 81 matching lines @@
         value(value),
         size(size),
         info((binding << 4) | type),
         other(0),
         section(section) {
   }
 
   Binding binding() const {
     return static_cast<Binding>(info >> 4);
   }
-#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_X87
   struct SerializedLayout {
     SerializedLayout(uint32_t name,
                      uintptr_t value,
                      uintptr_t size,
                      Binding binding,
                      Type type,
                      uint16_t section)
         : name(name),
           value(value),
           size(size),
@@ skipping 301 matching lines @@
     w->WriteString("v8value");
 
     if (desc_->IsInfoAvailable()) {
       Scope* scope = desc_->info()->scope();
       w->WriteULEB128(2);
       w->WriteString(desc_->name());
       w->Write<intptr_t>(desc_->CodeStart());
       w->Write<intptr_t>(desc_->CodeStart() + desc_->CodeSize());
       Writer::Slot<uint32_t> fb_block_size = w->CreateSlotHere<uint32_t>();
       uintptr_t fb_block_start = w->position();
-#if V8_TARGET_ARCH_IA32
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
       w->Write<uint8_t>(DW_OP_reg5);  // The frame pointer's here on ia32
 #elif V8_TARGET_ARCH_X64
       w->Write<uint8_t>(DW_OP_reg6);  // and here on x64.
 #elif V8_TARGET_ARCH_ARM
       UNIMPLEMENTED();
 #elif V8_TARGET_ARCH_MIPS
       UNIMPLEMENTED();
 #else
 #error Unsupported target architecture.
 #endif
@@ skipping 1069 matching lines @@
   LockGuard<Mutex> lock_guard(mutex.Pointer());
   ASSERT(!IsLineInfoTagged(line_info));
   HashMap::Entry* e = GetEntries()->Lookup(code, HashForCodeObject(code), true);
   ASSERT(e->value == NULL);
   e->value = TagLineInfo(line_info);
 }
 
 
 } }  // namespace v8::internal
 #endif