Update to latest jitdump file format

runtime/vm/os_linux.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_OS_LINUX)
 
 #include "vm/os.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 184 matching lines @@
 
   virtual void Notify(const char* name,
                       uword base,
                       uword prologue_offset,
                       uword size,
                       bool optimized) {
     WriteCodeLoad(name, base, prologue_offset, size, optimized);
   }
 
  private:
-  static const uint32_t kJitHeaderMagic = 0x4F74496A;
-  static const uint32_t kJitHeaderVersion = 0x2;
+  static const uint32_t kJitHeaderMagic = 0x4A695444;
+  static const uint32_t kJitHeaderMagicSw = 0x4454694A;
+  static const uint32_t kJitHeaderVersion = 0x1;
   static const uint32_t kElfMachIA32 = 3;
   static const uint32_t kElfMachX64 = 62;
   static const uint32_t kElfMachARM = 40;
   // TODO(zra): Find the right ARM64 constant.
   static const uint32_t kElfMachARM64 = 40;
   static const uint32_t kElfMachMIPS = 10;
   static const int kInvalidClockId = -1;
 
   struct jitheader {
-    uint32_t magic;
-    uint32_t version;
+    uint32_t magic;   /* characters "jItD" */
+    uint32_t version; /* header version */
+    uint32_t total_size;  /* total size of header */
+    uint32_t elf_mach;  /* elf mach target */
+    uint32_t pad1;    /* reserved */
+    uint32_t pid;   /* JIT process id */
+    uint64_t timestamp; /* timestamp */
+  };
+
+  /* record prefix (mandatory in each record) */
+  struct jr_prefix {
+    uint32_t id;
     uint32_t total_size;
-    uint32_t elf_mach;
-    uint32_t pad1;
-    uint32_t pid;
     uint64_t timestamp;
   };
 
   enum jit_record_type {
     JIT_CODE_LOAD = 0,
-    /* JIT_CODE_UNLOAD = 1, */
-    /* JIT_CODE_CLOSE = 2, */
-    /* JIT_CODE_DEBUG_INFO = 3, */
+    /* JIT_CODE_MOVE = 1, */
+    /* JIT_CODE_DEBUG_INFO = 2, */
+    /* JIT_CODE_CLOSE = 3, */
     JIT_CODE_MAX = 4,
   };
 
   struct jr_code_load {
-    uint32_t id;
-    uint32_t total_size;
-    uint64_t timestamp;
+    struct jr_prefix prefix;
     uint32_t pid;
     uint32_t tid;
     uint64_t vma;
     uint64_t code_addr;
-    uint32_t code_size;
+    uint64_t code_size;
     uint64_t code_index;
-    uint32_t align;
   };
 
   const char* GenerateCodeName(const char* name, bool optimized) {
     const char* format = "%s%s";
     const char* marker = optimized ? "*" : "";
     intptr_t len = OS::SNPrint(NULL, 0, format, marker, name);
     char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
     OS::SNPrint(buffer, len + 1, format, marker, name);
     return buffer;
   }
@@ skipping 35 matching lines @@
   }
 
   void WriteHeader() {
     Dart_FileWriteCallback file_write = Isolate::file_write_callback();
     ASSERT(file_write != NULL);
     ASSERT(out_file_ != NULL);
     jitheader header;
     header.magic = kJitHeaderMagic;
     header.version = kJitHeaderVersion;
     header.total_size = sizeof(jitheader);
-    header.pad1 = 0xdeadbeef;
+    header.pad1 = 0x0;
     header.elf_mach = GetElfMach();
     header.pid = getpid();
     header.timestamp = GetKernelTimeNanos();
     {
       MutexLocker ml(CodeObservers::mutex());
       (*file_write)(&header, sizeof(header), out_file_);
     }
   }
 
   void WriteCodeLoad(const char* name, uword base, uword prologue_offset,
                      uword code_size, bool optimized) {
     Dart_FileWriteCallback file_write = Isolate::file_write_callback();
     ASSERT(file_write != NULL);
     ASSERT(out_file_ != NULL);
 
     const char* code_name = GenerateCodeName(name, optimized);
     const intptr_t code_name_size = strlen(code_name) + 1;
     uint8_t* code_pointer = reinterpret_cast<uint8_t*>(base);
 
     jr_code_load code_load;
-    code_load.id = JIT_CODE_LOAD;
-    code_load.total_size = sizeof(code_load) + code_name_size + code_size;
-    code_load.timestamp = GetKernelTimeNanos();
+    code_load.prefix.id = JIT_CODE_LOAD;
+    code_load.prefix.total_size =
+        sizeof(code_load) + code_name_size + code_size;
+    code_load.prefix.timestamp = GetKernelTimeNanos();
     code_load.pid = getpid();
     code_load.tid = gettid();
     code_load.vma = 0x0;  //  Our addresses are absolute.
     code_load.code_addr = base;
     code_load.code_size = code_size;
-    code_load.align = OS::PreferredCodeAlignment();
 
     {
       MutexLocker ml(CodeObservers::mutex());
       // Set this field under the index.
       code_load.code_index = code_sequence_++;
       // Write structures.
       (*file_write)(&code_load, sizeof(code_load), out_file_);
       (*file_write)(code_name, code_name_size, out_file_);
       (*file_write)(code_pointer, code_size, out_file_);
     }
@@ skipping 276 matching lines @@
 }
 
 
 void OS::Exit(int code) {
   exit(code);
 }
 
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)