Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/src/share/vm/jfr/recorder/checkpoint/jfrCheckpointWriter.cpp	Fri Dec 06 12:42:29 2019 +0100
     1.2 +++ b/src/share/vm/jfr/recorder/checkpoint/jfrCheckpointWriter.cpp	Tue Jun 16 11:03:04 2020 +0800
     1.3 @@ -44,13 +44,13 @@
     1.4    }
     1.5  }
     1.6  
     1.7 -static void write_checkpoint_header(u1* pos, jlong size, jlong time, bool flushpoint, juint type_count) {
     1.8 +static void write_checkpoint_header(u1* pos, int64_t size, jlong time, bool flushpoint, u4 type_count) {
     1.9    assert(pos != NULL, "invariant");
    1.10    JfrBigEndianWriter be_writer(pos, sizeof(JfrCheckpointEntry));
    1.11    be_writer.write(size);
    1.12    be_writer.write(time);
    1.13    be_writer.write(JfrTicks::now().value() - time);
    1.14 -  be_writer.write(flushpoint ? (juint)1 : (juint)0);
    1.15 +  be_writer.write(flushpoint ? (u4)1 : (u4)0);
    1.16    be_writer.write(type_count);
    1.17    assert(be_writer.is_valid(), "invariant");
    1.18  }
    1.19 @@ -71,7 +71,7 @@
    1.20    assert(this->is_valid(), "invariant");
    1.21    assert(count() > 0, "invariant");
    1.22    assert(this->used_size() > sizeof(JfrCheckpointEntry), "invariant");
    1.23 -  const jlong size = this->current_offset();
    1.24 +  const int64_t size = this->current_offset();
    1.25    assert(size + this->start_pos() == this->current_pos(), "invariant");
    1.26    write_checkpoint_header(const_cast<u1*>(this->start_pos()), size, _time, is_flushpoint(), count());
    1.27    release();
    1.28 @@ -85,11 +85,11 @@
    1.29    return _flushpoint;
    1.30  }
    1.31  
    1.32 -juint JfrCheckpointWriter::count() const {
    1.33 +u4 JfrCheckpointWriter::count() const {
    1.34    return _count;
    1.35  }
    1.36  
    1.37 -void JfrCheckpointWriter::set_count(juint count) {
    1.38 +void JfrCheckpointWriter::set_count(u4 count) {
    1.39    _count = count;
    1.40  }
    1.41  
    1.42 @@ -111,7 +111,7 @@
    1.43  }
    1.44  
    1.45  void JfrCheckpointWriter::write_key(u8 key) {
    1.46 -  write<u8>(key);
    1.47 +  write(key);
    1.48  }
    1.49  
    1.50  void JfrCheckpointWriter::increment() {
    1.51 @@ -119,10 +119,10 @@
    1.52  }
    1.53  
    1.54  void JfrCheckpointWriter::write_count(u4 nof_entries) {
    1.55 -  write<u4>((u4)nof_entries);
    1.56 +  write(nof_entries);
    1.57  }
    1.58  
    1.59 -void JfrCheckpointWriter::write_count(u4 nof_entries, jlong offset) {
    1.60 +void JfrCheckpointWriter::write_count(u4 nof_entries, int64_t offset) {
    1.61    write_padded_at_offset(nof_entries, offset);
    1.62  }
    1.63  

     2.1 --- a/src/share/vm/jfr/recorder/checkpoint/jfrCheckpointWriter.hpp	Fri Dec 06 12:42:29 2019 +0100
     2.2 +++ b/src/share/vm/jfr/recorder/checkpoint/jfrCheckpointWriter.hpp	Tue Jun 16 11:03:04 2020 +0800
     2.3 @@ -49,21 +49,21 @@
     2.4  typedef EventWriterHost<BigEndianEncoder, CompressedIntegerEncoder, JfrTransactionalCheckpointWriter> JfrCheckpointWriterBase;
     2.5  
     2.6  struct JfrCheckpointContext {
     2.7 -  jlong offset;
     2.8 -  juint count;
     2.9 +  int64_t offset;
    2.10 +  u4 count;
    2.11  };
    2.12  
    2.13  class JfrCheckpointWriter : public JfrCheckpointWriterBase {
    2.14    friend class JfrSerializerRegistration;
    2.15   private:
    2.16    JfrTicks _time;
    2.17 -  jlong _offset;
    2.18 -  juint _count;
    2.19 +  int64_t _offset;
    2.20 +  u4 _count;
    2.21    bool _flushpoint;
    2.22    bool _header;
    2.23  
    2.24 -  juint count() const;
    2.25 -  void set_count(juint count);
    2.26 +  u4 count() const;
    2.27 +  void set_count(u4 count);
    2.28    void increment();
    2.29    void set_flushpoint(bool flushpoint);
    2.30    bool is_flushpoint() const;
    2.31 @@ -75,7 +75,7 @@
    2.32    ~JfrCheckpointWriter();
    2.33    void write_type(JfrTypeId type_id);
    2.34    void write_count(u4 nof_entries);
    2.35 -  void write_count(u4 nof_entries, jlong offset);
    2.36 +  void write_count(u4 nof_entries, int64_t offset);
    2.37    void write_key(u8 key);
    2.38    const JfrCheckpointContext context() const;
    2.39    void set_context(const JfrCheckpointContext ctx);

     3.1 --- a/src/share/vm/jfr/recorder/checkpoint/types/jfrType.cpp	Fri Dec 06 12:42:29 2019 +0100
     3.2 +++ b/src/share/vm/jfr/recorder/checkpoint/types/jfrType.cpp	Tue Jun 16 11:03:04 2020 +0800
     3.3 @@ -64,7 +64,7 @@
     3.4   private:
     3.5    JfrCheckpointWriter& _writer;
     3.6    JfrCheckpointContext _ctx;
     3.7 -  const intptr_t _count_position;
     3.8 +  const int64_t _count_position;
     3.9    Thread* const _curthread;
    3.10    u4 _count;
    3.11  

     4.1 --- a/src/share/vm/jfr/recorder/checkpoint/types/jfrTypeSetWriter.hpp	Fri Dec 06 12:42:29 2019 +0100
     4.2 +++ b/src/share/vm/jfr/recorder/checkpoint/types/jfrTypeSetWriter.hpp	Tue Jun 16 11:03:04 2020 +0800
     4.3 @@ -35,7 +35,7 @@
     4.4    WriterImpl _impl;
     4.5    JfrCheckpointWriter* _writer;
     4.6    JfrCheckpointContext _ctx;
     4.7 -  jlong _count_offset;
     4.8 +  int64_t _count_offset;
     4.9    int _count;
    4.10    bool _skip_header;
    4.11   public:

     5.1 --- a/src/share/vm/jfr/recorder/repository/jfrChunkState.cpp	Fri Dec 06 12:42:29 2019 +0100
     5.2 +++ b/src/share/vm/jfr/recorder/repository/jfrChunkState.cpp	Tue Jun 16 11:03:04 2020 +0800
     5.3 @@ -52,19 +52,19 @@
     5.4    set_previous_checkpoint_offset(0);
     5.5  }
     5.6  
     5.7 -void JfrChunkState::set_previous_checkpoint_offset(jlong offset) {
     5.8 +void JfrChunkState::set_previous_checkpoint_offset(int64_t offset) {
     5.9    _previous_checkpoint_offset = offset;
    5.10  }
    5.11  
    5.12 -jlong JfrChunkState::previous_checkpoint_offset() const {
    5.13 +int64_t JfrChunkState::previous_checkpoint_offset() const {
    5.14    return _previous_checkpoint_offset;
    5.15  }
    5.16  
    5.17 -jlong JfrChunkState::previous_start_ticks() const {
    5.18 +int64_t JfrChunkState::previous_start_ticks() const {
    5.19    return _previous_start_ticks;
    5.20  }
    5.21  
    5.22 -jlong JfrChunkState::previous_start_nanos() const {
    5.23 +int64_t JfrChunkState::previous_start_nanos() const {
    5.24    return _previous_start_nanos;
    5.25  }
    5.26  
    5.27 @@ -91,7 +91,7 @@
    5.28    save_current_and_update_start_ticks();
    5.29  }
    5.30  
    5.31 -jlong JfrChunkState::last_chunk_duration() const {
    5.32 +int64_t JfrChunkState::last_chunk_duration() const {
    5.33    return _start_nanos - _previous_start_nanos;
    5.34  }
    5.35  

     6.1 --- a/src/share/vm/jfr/recorder/repository/jfrChunkState.hpp	Fri Dec 06 12:42:29 2019 +0100
     6.2 +++ b/src/share/vm/jfr/recorder/repository/jfrChunkState.hpp	Tue Jun 16 11:03:04 2020 +0800
     6.3 @@ -25,7 +25,6 @@
     6.4  #ifndef SHARE_VM_JFR_RECORDER_REPOSITORY_JFRRCHUNKSTATE_HPP
     6.5  #define SHARE_VM_JFR_RECORDER_REPOSITORY_JFRRCHUNKSTATE_HPP
     6.6  
     6.7 -#include "jni.h"
     6.8  #include "jfr/utilities/jfrAllocation.hpp"
     6.9  #include "jfr/utilities/jfrTypes.hpp"
    6.10  
    6.11 @@ -33,11 +32,11 @@
    6.12    friend class JfrChunkWriter;
    6.13   private:
    6.14    char* _path;
    6.15 -  jlong _start_ticks;
    6.16 -  jlong _start_nanos;
    6.17 -  jlong _previous_start_ticks;
    6.18 -  jlong _previous_start_nanos;
    6.19 -  jlong _previous_checkpoint_offset;
    6.20 +  int64_t _start_ticks;
    6.21 +  int64_t _start_nanos;
    6.22 +  int64_t _previous_start_ticks;
    6.23 +  int64_t _previous_start_nanos;
    6.24 +  int64_t _previous_checkpoint_offset;
    6.25  
    6.26    void update_start_ticks();
    6.27    void update_start_nanos();
    6.28 @@ -47,11 +46,11 @@
    6.29    JfrChunkState();
    6.30    ~JfrChunkState();
    6.31    void reset();
    6.32 -  jlong previous_checkpoint_offset() const;
    6.33 -  void set_previous_checkpoint_offset(jlong offset);
    6.34 -  jlong previous_start_ticks() const;
    6.35 -  jlong previous_start_nanos() const;
    6.36 -  jlong last_chunk_duration() const;
    6.37 +  int64_t previous_checkpoint_offset() const;
    6.38 +  void set_previous_checkpoint_offset(int64_t offset);
    6.39 +  int64_t previous_start_ticks() const;
    6.40 +  int64_t previous_start_nanos() const;
    6.41 +  int64_t last_chunk_duration() const;
    6.42    void update_time_to_now();
    6.43    void set_path(const char* path);
    6.44    const char* path() const;

     7.1 --- a/src/share/vm/jfr/recorder/repository/jfrChunkWriter.cpp	Fri Dec 06 12:42:29 2019 +0100
     7.2 +++ b/src/share/vm/jfr/recorder/repository/jfrChunkWriter.cpp	Tue Jun 16 11:03:04 2020 +0800
     7.3 @@ -32,9 +32,8 @@
     7.4  #include "runtime/os.hpp"
     7.5  #include "runtime/os.hpp"
     7.6  
     7.7 -const u2 JFR_VERSION_MAJOR = 2;
     7.8 -const u2 JFR_VERSION_MINOR = 0;
     7.9 -
    7.10 +static const u2 JFR_VERSION_MAJOR = 2;
    7.11 +static const u2 JFR_VERSION_MINOR = 0;
    7.12  static const size_t MAGIC_LEN = 4;
    7.13  static const size_t FILEHEADER_SLOT_SIZE = 8;
    7.14  static const size_t CHUNK_SIZE_OFFSET = 8;
    7.15 @@ -79,14 +78,14 @@
    7.16    return is_open;
    7.17  }
    7.18  
    7.19 -size_t JfrChunkWriter::close(intptr_t metadata_offset) {
    7.20 +size_t JfrChunkWriter::close(int64_t metadata_offset) {
    7.21    write_header(metadata_offset);
    7.22    this->flush();
    7.23    this->close_fd();
    7.24 -  return size_written();
    7.25 +  return (size_t)size_written();
    7.26  }
    7.27  
    7.28 -void JfrChunkWriter::write_header(intptr_t metadata_offset) {
    7.29 +void JfrChunkWriter::write_header(int64_t metadata_offset) {
    7.30    assert(this->is_valid(), "invariant");
    7.31    // Chunk size
    7.32    this->write_be_at_offset((jlong)size_written(), CHUNK_SIZE_OFFSET);
    7.33 @@ -106,15 +105,15 @@
    7.34    _chunkstate->set_path(chunk_path);
    7.35  }
    7.36  
    7.37 -intptr_t JfrChunkWriter::size_written() const {
    7.38 +int64_t JfrChunkWriter::size_written() const {
    7.39    return this->is_valid() ? this->current_offset() : 0;
    7.40  }
    7.41  
    7.42 -intptr_t JfrChunkWriter::previous_checkpoint_offset() const {
    7.43 +int64_t JfrChunkWriter::previous_checkpoint_offset() const {
    7.44    return _chunkstate->previous_checkpoint_offset();
    7.45  }
    7.46  
    7.47 -void JfrChunkWriter::set_previous_checkpoint_offset(intptr_t offset) {
    7.48 +void JfrChunkWriter::set_previous_checkpoint_offset(int64_t offset) {
    7.49    _chunkstate->set_previous_checkpoint_offset(offset);
    7.50  }
    7.51  

     8.1 --- a/src/share/vm/jfr/recorder/repository/jfrChunkWriter.hpp	Fri Dec 06 12:42:29 2019 +0100
     8.2 +++ b/src/share/vm/jfr/recorder/repository/jfrChunkWriter.hpp	Tue Jun 16 11:03:04 2020 +0800
     8.3 @@ -41,16 +41,16 @@
     8.4    JfrChunkState* _chunkstate;
     8.5  
     8.6    bool open();
     8.7 -  size_t close(intptr_t metadata_offset);
     8.8 -  void write_header(intptr_t metadata_offset);
     8.9 +  size_t close(int64_t metadata_offset);
    8.10 +  void write_header(int64_t metadata_offset);
    8.11    void set_chunk_path(const char* chunk_path);
    8.12  
    8.13   public:
    8.14    JfrChunkWriter();
    8.15    bool initialize();
    8.16 -  intptr_t size_written() const;
    8.17 -  intptr_t previous_checkpoint_offset() const;
    8.18 -  void set_previous_checkpoint_offset(intptr_t offset);
    8.19 +  int64_t size_written() const;
    8.20 +  int64_t previous_checkpoint_offset() const;
    8.21 +  void set_previous_checkpoint_offset(int64_t offset);
    8.22    void time_stamp_chunk_now();
    8.23  };
    8.24  

     9.1 --- a/src/share/vm/jfr/recorder/repository/jfrRepository.cpp	Fri Dec 06 12:42:29 2019 +0100
     9.2 +++ b/src/share/vm/jfr/recorder/repository/jfrRepository.cpp	Tue Jun 16 11:03:04 2020 +0800
     9.3 @@ -147,10 +147,10 @@
     9.4    iso8601_to_date_time(buffer);
     9.5  }
     9.6  
     9.7 -static jlong file_size(fio_fd fd) {
     9.8 +static int64_t file_size(fio_fd fd) {
     9.9    assert(fd != invalid_fd, "invariant");
    9.10 -  const jlong current_offset = os::current_file_offset(fd);
    9.11 -  const jlong size = os::lseek(fd, 0, SEEK_END);
    9.12 +  const int64_t current_offset = os::current_file_offset(fd);
    9.13 +  const int64_t size = os::lseek(fd, 0, SEEK_END);
    9.14    os::seek_to_file_offset(fd, current_offset);
    9.15    return size;
    9.16  }
    9.17 @@ -218,7 +218,7 @@
    9.18    if (invalid_fd == entry_fd) {
    9.19      return NULL;
    9.20    }
    9.21 -  const jlong entry_size = file_size(entry_fd);
    9.22 +  const int64_t entry_size = file_size(entry_fd);
    9.23    os::close(entry_fd);
    9.24    if (0 == entry_size) {
    9.25      return NULL;
    9.26 @@ -260,6 +260,7 @@
    9.27    }
    9.28  }
    9.29  #endif
    9.30 +
    9.31  bool RepositoryIterator::has_next() const {
    9.32    return (_files != NULL && _iterator < _files->length());
    9.33  }
    9.34 @@ -275,21 +276,26 @@
    9.35    if (file_copy_block == NULL) {
    9.36      return;
    9.37    }
    9.38 - jlong bytes_written_total = 0;
    9.39 + int64_t bytes_written_total = 0;
    9.40    while (iterator.has_next()) {
    9.41      fio_fd current_fd = invalid_fd;
    9.42      const char* const fqn = iterator.next();
    9.43      if (fqn != NULL) {
    9.44        current_fd = open_existing(fqn);
    9.45        if (current_fd != invalid_fd) {
    9.46 -        const jlong current_filesize = file_size(current_fd);
    9.47 +        const int64_t current_filesize = file_size(current_fd);
    9.48          assert(current_filesize > 0, "invariant");
    9.49 -        jlong bytes_read = 0;
    9.50 -        jlong bytes_written = 0;
    9.51 +        int64_t bytes_read = 0;
    9.52 +        int64_t bytes_written = 0;
    9.53          while (bytes_read < current_filesize) {
    9.54 -          bytes_read += (jlong)os::read_at(current_fd, file_copy_block, size_of_file_copy_block, bytes_read);
    9.55 -          assert(bytes_read - bytes_written <= (jlong)size_of_file_copy_block, "invariant");
    9.56 -          bytes_written += (jlong)os::write(emergency_fd, file_copy_block, bytes_read - bytes_written);
    9.57 +          const ssize_t read_result = os::read_at(current_fd, file_copy_block, size_of_file_copy_block, bytes_read);
    9.58 +          if (-1 == read_result) {
    9.59 +            if (LogJFR) tty->print_cr("Unable to recover JFR data");
    9.60 +            break;
    9.61 +          }
    9.62 +          bytes_read += (int64_t)read_result;
    9.63 +          assert(bytes_read - bytes_written <= (int64_t)size_of_file_copy_block, "invariant");
    9.64 +          bytes_written += (int64_t)os::write(emergency_fd, file_copy_block, bytes_read - bytes_written);
    9.65            assert(bytes_read == bytes_written, "invariant");
    9.66          }
    9.67          os::close(current_fd);
    9.68 @@ -468,6 +474,6 @@
    9.69    return _chunkwriter->open();
    9.70  }
    9.71  
    9.72 -size_t JfrRepository::close_chunk(jlong metadata_offset) {
    9.73 +size_t JfrRepository::close_chunk(int64_t metadata_offset) {
    9.74    return _chunkwriter->close(metadata_offset);
    9.75  }

    10.1 --- a/src/share/vm/jfr/recorder/repository/jfrRepository.hpp	Fri Dec 06 12:42:29 2019 +0100
    10.2 +++ b/src/share/vm/jfr/recorder/repository/jfrRepository.hpp	Tue Jun 16 11:03:04 2020 +0800
    10.3 @@ -55,7 +55,7 @@
    10.4    bool set_path(const char* path);
    10.5    void set_chunk_path(const char* path);
    10.6    bool open_chunk(bool vm_error = false);
    10.7 -  size_t close_chunk(jlong metadata_offset);
    10.8 +  size_t close_chunk(int64_t metadata_offset);
    10.9    void on_vm_error();
   10.10    static void notify_on_new_chunk_path();
   10.11    static JfrChunkWriter& chunkwriter();

    11.1 --- a/src/share/vm/jfr/recorder/service/jfrRecorderService.cpp	Fri Dec 06 12:42:29 2019 +0100
    11.2 +++ b/src/share/vm/jfr/recorder/service/jfrRecorderService.cpp	Tue Jun 16 11:03:04 2020 +0800
    11.3 @@ -131,18 +131,18 @@
    11.4    bool not_acquired() const { return !_acquired; }
    11.5  };
    11.6  
    11.7 -static intptr_t write_checkpoint_event_prologue(JfrChunkWriter& cw, u8 type_id) {
    11.8 -  const intptr_t prev_cp_offset = cw.previous_checkpoint_offset();
    11.9 -  const intptr_t prev_cp_relative_offset = 0 == prev_cp_offset ? 0 : prev_cp_offset - cw.current_offset();
   11.10 +static int64_t write_checkpoint_event_prologue(JfrChunkWriter& cw, u8 type_id) {
   11.11 +  const int64_t prev_cp_offset = cw.previous_checkpoint_offset();
   11.12 +  const int64_t prev_cp_relative_offset = 0 == prev_cp_offset ? 0 : prev_cp_offset - cw.current_offset();
   11.13    cw.reserve(sizeof(u4));
   11.14    cw.write<u8>(EVENT_CHECKPOINT);
   11.15    cw.write(JfrTicks::now());
   11.16 -  cw.write<jlong>((jlong)0);
   11.17 -  cw.write<jlong>((jlong)prev_cp_relative_offset); // write previous checkpoint offset delta
   11.18 +  cw.write((int64_t)0);
   11.19 +  cw.write(prev_cp_relative_offset); // write previous checkpoint offset delta
   11.20    cw.write<bool>(false); // flushpoint
   11.21 -  cw.write<u4>((u4)1); // nof types in this checkpoint
   11.22 -  cw.write<u8>(type_id);
   11.23 -  const intptr_t number_of_elements_offset = cw.current_offset();
   11.24 +  cw.write((u4)1); // nof types in this checkpoint
   11.25 +  cw.write(type_id);
   11.26 +  const int64_t number_of_elements_offset = cw.current_offset();
   11.27    cw.reserve(sizeof(u4));
   11.28    return number_of_elements_offset;
   11.29  }
   11.30 @@ -162,8 +162,8 @@
   11.31    }
   11.32    bool process() {
   11.33      // current_cp_offset is also offset for the event size header field
   11.34 -    const intptr_t current_cp_offset = _cw.current_offset();
   11.35 -    const intptr_t num_elements_offset = write_checkpoint_event_prologue(_cw, _type_id);
   11.36 +    const int64_t current_cp_offset = _cw.current_offset();
   11.37 +    const int64_t num_elements_offset = write_checkpoint_event_prologue(_cw, _type_id);
   11.38      // invocation
   11.39      _content_functor.process();
   11.40      const u4 number_of_elements = (u4)_content_functor.processed();
   11.41 @@ -476,9 +476,9 @@
   11.42    JfrMetadataEvent::lock();
   11.43  }
   11.44  
   11.45 -static jlong write_metadata_event(JfrChunkWriter& chunkwriter) {
   11.46 +static int64_t write_metadata_event(JfrChunkWriter& chunkwriter) {
   11.47    assert(chunkwriter.is_valid(), "invariant");
   11.48 -  const jlong metadata_offset = chunkwriter.current_offset();
   11.49 +  const int64_t metadata_offset = chunkwriter.current_offset();
   11.50    JfrMetadataEvent::write(chunkwriter, metadata_offset);
   11.51    return metadata_offset;
   11.52  }

    12.1 --- a/src/share/vm/jfr/writers/jfrEventWriterHost.inline.hpp	Fri Dec 06 12:42:29 2019 +0100
    12.2 +++ b/src/share/vm/jfr/writers/jfrEventWriterHost.inline.hpp	Tue Jun 16 11:03:04 2020 +0800
    12.3 @@ -49,7 +49,7 @@
    12.4  inline intptr_t EventWriterHost<BE, IE, WriterPolicyImpl>::end_write(void) {
    12.5    assert(this->is_acquired(),
    12.6      "state corruption, calling end with writer with non-acquired state!");
    12.7 -  return this->is_valid() ? this->used_offset() : 0;
    12.8 +  return this->is_valid() ? (intptr_t)this->used_offset() : 0;
    12.9  }
   12.10  
   12.11  template <typename BE, typename IE, typename WriterPolicyImpl>

    13.1 --- a/src/share/vm/jfr/writers/jfrPosition.hpp	Fri Dec 06 12:42:29 2019 +0100
    13.2 +++ b/src/share/vm/jfr/writers/jfrPosition.hpp	Tue Jun 16 11:03:04 2020 +0800
    13.3 @@ -48,8 +48,8 @@
    13.4  
    13.5   public:
    13.6    size_t available_size() const;
    13.7 -  intptr_t used_offset() const;
    13.8 -  intptr_t current_offset() const;
    13.9 +  int64_t used_offset() const;
   13.10 +  int64_t current_offset() const;
   13.11    size_t used_size() const;
   13.12    void reset();
   13.13  };

    14.1 --- a/src/share/vm/jfr/writers/jfrPosition.inline.hpp	Fri Dec 06 12:42:29 2019 +0100
    14.2 +++ b/src/share/vm/jfr/writers/jfrPosition.inline.hpp	Tue Jun 16 11:03:04 2020 +0800
    14.3 @@ -80,12 +80,12 @@
    14.4  }
    14.5  
    14.6  template <typename AP>
    14.7 -inline intptr_t Position<AP>::used_offset() const {
    14.8 +inline int64_t Position<AP>::used_offset() const {
    14.9    return _current_pos - _start_pos;
   14.10  }
   14.11  
   14.12  template <typename AP>
   14.13 -inline intptr_t Position<AP>::current_offset() const {
   14.14 +inline int64_t Position<AP>::current_offset() const {
   14.15    return this->used_offset();
   14.16  }
   14.17  

    15.1 --- a/src/share/vm/jfr/writers/jfrStreamWriterHost.hpp	Fri Dec 06 12:42:29 2019 +0100
    15.2 +++ b/src/share/vm/jfr/writers/jfrStreamWriterHost.hpp	Tue Jun 16 11:03:04 2020 +0800
    15.3 @@ -33,9 +33,9 @@
    15.4   public:
    15.5    typedef typename Adapter::StorageType StorageType;
    15.6   private:
    15.7 -  intptr_t _stream_pos;
    15.8 +  int64_t _stream_pos;
    15.9    fio_fd _fd;
   15.10 -  intptr_t current_stream_position() const;
   15.11 +  int64_t current_stream_position() const;
   15.12  
   15.13   protected:
   15.14    StreamWriterHost(StorageType* storage, Thread* thread);
   15.15 @@ -47,8 +47,8 @@
   15.16    bool has_valid_fd() const;
   15.17  
   15.18   public:
   15.19 -  intptr_t current_offset() const;
   15.20 -  void seek(intptr_t offset);
   15.21 +  int64_t current_offset() const;
   15.22 +  void seek(int64_t offset);
   15.23    void flush();
   15.24    void write_unbuffered(const void* src, size_t len);
   15.25    bool is_valid() const;

    16.1 --- a/src/share/vm/jfr/writers/jfrStreamWriterHost.inline.hpp	Fri Dec 06 12:42:29 2019 +0100
    16.2 +++ b/src/share/vm/jfr/writers/jfrStreamWriterHost.inline.hpp	Tue Jun 16 11:03:04 2020 +0800
    16.3 @@ -44,7 +44,7 @@
    16.4  }
    16.5  
    16.6  template <typename Adapter, typename AP>
    16.7 -inline intptr_t StreamWriterHost<Adapter, AP>::current_stream_position() const {
    16.8 +inline int64_t StreamWriterHost<Adapter, AP>::current_stream_position() const {
    16.9    return this->used_offset() + _stream_pos;
   16.10  }
   16.11  
   16.12 @@ -73,7 +73,7 @@
   16.13  inline void StreamWriterHost<Adapter, AP>::flush(size_t size) {
   16.14    assert(size > 0, "invariant");
   16.15    assert(this->is_valid(), "invariant");
   16.16 -  _stream_pos += os::write(_fd, this->start_pos(), (int)size);
   16.17 +  _stream_pos += os::write(_fd, this->start_pos(), (unsigned int)size);
   16.18    StorageHost<Adapter, AP>::reset();
   16.19    assert(0 == this->used_offset(), "invariant");
   16.20  }
   16.21 @@ -84,12 +84,12 @@
   16.22  }
   16.23  
   16.24  template <typename Adapter, typename AP>
   16.25 -inline intptr_t StreamWriterHost<Adapter, AP>::current_offset() const {
   16.26 +inline int64_t StreamWriterHost<Adapter, AP>::current_offset() const {
   16.27    return current_stream_position();
   16.28  }
   16.29  
   16.30  template <typename Adapter, typename AP>
   16.31 -void StreamWriterHost<Adapter, AP>::seek(intptr_t offset) {
   16.32 +void StreamWriterHost<Adapter, AP>::seek(int64_t offset) {
   16.33    this->flush();
   16.34    assert(0 == this->used_offset(), "can only seek from beginning");
   16.35    _stream_pos = os::seek_to_file_offset(_fd, offset);
   16.36 @@ -110,7 +110,7 @@
   16.37    this->flush();
   16.38    assert(0 == this->used_offset(), "can only seek from beginning");
   16.39    while (len > 0) {
   16.40 -    const int n = MIN2<int>((int)len, INT_MAX);
   16.41 +    const unsigned int n = MIN2((unsigned int)len, (unsigned int)INT_MAX);
   16.42      _stream_pos += os::write(_fd, buf, n);
   16.43      len -= n;
   16.44    }

    17.1 --- a/src/share/vm/jfr/writers/jfrWriterHost.hpp	Fri Dec 06 12:42:29 2019 +0100
    17.2 +++ b/src/share/vm/jfr/writers/jfrWriterHost.hpp	Tue Jun 16 11:03:04 2020 +0800
    17.3 @@ -87,12 +87,12 @@
    17.4    void bytes(const void* buf, size_t len);
    17.5    void write_utf8_u2_len(const char* value);
    17.6    template <typename T>
    17.7 -  void write_padded_at_offset(T value, intptr_t offset);
    17.8 +  void write_padded_at_offset(T value, int64_t offset);
    17.9    template <typename T>
   17.10 -  void write_at_offset(T value, intptr_t offset);
   17.11 +  void write_at_offset(T value, int64_t offset);
   17.12    template <typename T>
   17.13 -  void write_be_at_offset(T value, intptr_t offset);
   17.14 -  intptr_t reserve(size_t size);
   17.15 +  void write_be_at_offset(T value, int64_t offset);
   17.16 +  int64_t reserve(size_t size);
   17.17  };
   17.18  
   17.19  #endif // SHARE_VM_JFR_WRITERS_JFRWRITERHOST_HPP

    18.1 --- a/src/share/vm/jfr/writers/jfrWriterHost.inline.hpp	Fri Dec 06 12:42:29 2019 +0100
    18.2 +++ b/src/share/vm/jfr/writers/jfrWriterHost.inline.hpp	Tue Jun 16 11:03:04 2020 +0800
    18.3 @@ -306,9 +306,9 @@
    18.4  }
    18.5  
    18.6  template <typename BE, typename IE, typename WriterPolicyImpl>
    18.7 -inline intptr_t WriterHost<BE, IE, WriterPolicyImpl>::reserve(size_t size) {
    18.8 +inline int64_t WriterHost<BE, IE, WriterPolicyImpl>::reserve(size_t size) {
    18.9    if (ensure_size(size) != NULL) {
   18.10 -    intptr_t reserved_offset = this->current_offset();
   18.11 +    const int64_t reserved_offset = this->current_offset();
   18.12      this->set_current_pos(size);
   18.13      return reserved_offset;
   18.14    }
   18.15 @@ -318,9 +318,9 @@
   18.16  
   18.17  template <typename BE, typename IE, typename WriterPolicyImpl>
   18.18  template <typename T>
   18.19 -inline void WriterHost<BE, IE, WriterPolicyImpl>::write_padded_at_offset(T value, intptr_t offset) {
   18.20 +inline void WriterHost<BE, IE, WriterPolicyImpl>::write_padded_at_offset(T value, int64_t offset) {
   18.21    if (this->is_valid()) {
   18.22 -    const intptr_t current = this->current_offset();
   18.23 +    const int64_t current = this->current_offset();
   18.24      this->seek(offset);
   18.25      write_padded(value);
   18.26      this->seek(current); // restore
   18.27 @@ -329,9 +329,9 @@
   18.28  
   18.29  template <typename BE, typename IE, typename WriterPolicyImpl>
   18.30  template <typename T>
   18.31 -inline void WriterHost<BE, IE, WriterPolicyImpl>::write_at_offset(T value, intptr_t offset) {
   18.32 +inline void WriterHost<BE, IE, WriterPolicyImpl>::write_at_offset(T value, int64_t offset) {
   18.33    if (this->is_valid()) {
   18.34 -    const intptr_t current = this->current_offset();
   18.35 +    const int64_t current = this->current_offset();
   18.36      this->seek(offset);
   18.37      write(value);
   18.38      this->seek(current); // restore
   18.39 @@ -340,9 +340,9 @@
   18.40  
   18.41  template <typename BE, typename IE, typename WriterPolicyImpl>
   18.42  template <typename T>
   18.43 -inline void WriterHost<BE, IE, WriterPolicyImpl>::write_be_at_offset(T value, intptr_t offset) {
   18.44 +inline void WriterHost<BE, IE, WriterPolicyImpl>::write_be_at_offset(T value, int64_t offset) {
   18.45    if (this->is_valid()) {
   18.46 -    const intptr_t current = this->current_offset();
   18.47 +    const int64_t current = this->current_offset();
   18.48      this->seek(offset);
   18.49      be_write(value);
   18.50      this->seek(current); // restore