rocr: Separate Linux coredump implementation (#1588)

Remove libamdhsacode/win32/elf.h due to license restrictions.

Separate Linux coredump implementation because we do not have the ELF
definitions on Windows.

Co-authored-by: JeniferC99 <150404595+JeniferC99@users.noreply.github.com>

projects/rocr-runtime/runtime/hsa-runtime/CMakeLists.txt

@@ -223,17 +223,18 @@ set ( SRCS core/driver/driver.cpp
            libamdhsacode/amd_hsa_code_util.cpp
            libamdhsacode/amd_hsa_locks.cpp
            libamdhsacode/amd_options.cpp
-           libamdhsacode/amd_hsa_code.cpp
-           libamdhsacode/amd_core_dump.cpp )
+           libamdhsacode/amd_hsa_code.cpp)
 
 if(UNIX)
-  set(SRC_OS core/util/lnx/os_linux.cpp)
+  set(SRC_OS core/util/lnx/os_linux.cpp
+	     libamdhsacode/lnx/amd_core_dump.cpp)
   set(SRC_XDNA core/driver/xdna/amd_xdna_driver.cpp
                core/runtime/amd_aie_agent.cpp
                core/runtime/amd_aie_aql_queue.cpp)
 else()
   target_compile_definitions(${CORE_RUNTIME_TARGET} PRIVATE NOMINMAX)
-  set(SRC_OS core/util/win/os_win.cpp)
+  set(SRC_OS core/util/win/os_win.cpp
+	     libamdhsacode/win32/amd_core_dump.cpp)
 endif()
          
 if ( BUILD_THUNK_VIRTIO )

projects/rocr-runtime/runtime/hsa-runtime/libamdhsacode/lnx/amd_core_dump.cpp

@@ -40,15 +40,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(__linux__)
 #include <unistd.h>
 #include <sys/resource.h>
 #include <elf.h>
-#else
-#include <cstdint>
-#include <stdio.h>
-#include <win32/elf.h>
-#endif
 #include <fcntl.h>
 #include <cstring>
 #include <vector>
@@ -227,7 +221,6 @@ struct LoadSegmentBuilder : public SegmentBuilder {
   ~LoadSegmentBuilder() {
     if (fd_ != -1) close(fd_);
   }
-
   hsa_status_t Collect(SegmentsInfo& segments) override {
     const std::string maps_path = "/proc/self/maps";
     std::ifstream maps(maps_path);
@@ -278,12 +271,8 @@ struct LoadSegmentBuilder : public SegmentBuilder {
     size_t done = 0;
     size_t read;
     do {
-    #if defined(__linux__)
       read = pread(fd_, static_cast<char *>(buf) + done, buf_size - done,
                    offset + done);
-    #else
-      assert(!"Unimplemented!");
-    #endif
       if (read == -1 && errno != EINTR) {
         perror("Failed to read GPU memory");
         return HSA_STATUS_ERROR;
@@ -314,7 +303,7 @@ hsa_status_t build_core_dump(const std::string& filename, const SegmentsInfo& se
     debug_print("Core file size over limit\n");
     return HSA_STATUS_SUCCESS;
   }
-#if defined(__linux__)
+
   int fd = open(filename.c_str(), O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
   if (fd == -1) {
     perror("Failed to create GPU coredump");
@@ -433,9 +422,7 @@ hsa_status_t build_core_dump(const std::string& filename, const SegmentsInfo& se
   }
   printf("GPU core dump created: %s\n", filename.c_str());
   close(fd);
-#else
-  assert(!"Unimplemented!");
-#endif
+
   return HSA_STATUS_SUCCESS;
 }
 }   //  namespace impl
@@ -444,7 +431,6 @@ hsa_status_t dump_gpu_core() {
   impl::NoteSegmentBuilder nbuilder;
   impl::LoadSegmentBuilder lbuilder;
   impl::SegmentsInfo segments;
-#if defined(__linux__)
   struct rlimit rlimit;
 
   if (getrlimit(RLIMIT_CORE, &rlimit)) {
@@ -464,11 +450,8 @@ hsa_status_t dump_gpu_core() {
 
   std::stringstream st;
   st << PREFIX_FILE_NAME << "." << getpid();
+
   return build_core_dump(st.str(), segments, rlimit.rlim_cur);
-#else
-  assert(!"Unimplemented!");
-  return HSA_STATUS_SUCCESS;
-#endif
 }
 }   //  namespace coredump
 }   //  namespace amd

projects/rocr-runtime/runtime/hsa-runtime/libamdhsacode/win32/amd_core_dump.cpp

@@ -0,0 +1,105 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// The University of Illinois/NCSA
+// Open Source License (NCSA)
+//
+// Copyright (c) 2023-2025, Advanced Micro Devices, Inc. All rights reserved.
+//
+// Developed by:
+//
+//                 AMD Research and AMD HSA Software Development
+//
+//                 Advanced Micro Devices, Inc.
+//
+//                 www.amd.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal with the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+//  - Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimers.
+//  - Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimers in
+//    the documentation and/or other materials provided with the distribution.
+//  - Neither the names of Advanced Micro Devices, Inc,
+//    nor the names of its contributors may be used to endorse or promote
+//    products derived from this Software without specific prior written
+//    permission.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS WITH THE SOFTWARE.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include "core/util/utils.h"
+#include "core/inc/runtime.h"
+#include "./amd_hsa_code_util.hpp"
+#include "core/inc/amd_core_dump.hpp"
+
+namespace rocr {
+namespace amd {
+namespace coredump {
+/* Implementation details */
+namespace impl {
+
+enum SegmentType { LOAD, NOTE };
+struct SegmentBuilder;
+
+struct SegmentInfo {
+  SegmentType stype;
+  uint64_t vaddr = 0;
+  uint64_t size = 0;
+  uint32_t flags = 0;
+  SegmentBuilder* builder;
+};
+
+using SegmentsInfo = std::vector<SegmentInfo>;
+
+struct SegmentBuilder {
+  virtual ~SegmentBuilder() = default;
+  /* Find which segments needs to be created.  */
+  virtual hsa_status_t Collect(SegmentsInfo& segments) = 0;
+  /* Called to read a given SegmentInfo's data.  */
+  virtual hsa_status_t Read(void* buf, size_t buf_size, off_t offset) = 0;
+};
+
+struct LoadSegmentBuilder : public SegmentBuilder {
+  LoadSegmentBuilder() {}
+  ~LoadSegmentBuilder() {}
+
+  hsa_status_t Collect(SegmentsInfo& segments) override {
+    assert(!"Unimplemented!");
+    return HSA_STATUS_ERROR;
+  }
+
+  hsa_status_t Read(void* buf, size_t buf_size, off_t offset) override {
+    assert(!"Unimplemented!");
+    return HSA_STATUS_ERROR;
+  }
+
+ private:
+  int fd_ = -1;
+};
+
+hsa_status_t build_core_dump(const std::string& filename, const SegmentsInfo& segments,
+                             size_t size_limit) {
+  assert(!"Unimplemented!");
+  return HSA_STATUS_ERROR;
+}
+}  // namespace impl
+hsa_status_t dump_gpu_core() {
+  assert(!"Unimplemented!");
+  return HSA_STATUS_ERROR;
+}
+}  //  namespace coredump
+}   //  namespace amd
+}   //  namespace rocr