[Comgr] New API to map ELF virtual address to code object offsets

lamb-j · lamb-j · commit a999d61d45eb · 2023-11-03T02:26:58.000-04:00
In this patch, we add a new Comgr API allowing a caller to map
an ELF virtual address to a code object offset for a given executable.
We also flag if the given address is in a NOBITS section, and the size
of the current bits/nobits section.

Change-Id: I304f1aad503a4de6a2c0db19fe55d77837851eb5
diff --git a/amd/comgr/CMakeLists.txt b/amd/comgr/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.13.4)
 
-project(amd_comgr VERSION "2.6.0" LANGUAGES C CXX)
+project(amd_comgr VERSION "2.7.0" LANGUAGES C CXX)
 set(amd_comgr_NAME "${PROJECT_NAME}")
 
 # Get git branch and commit hash to add to log for easier debugging.
diff --git a/amd/comgr/docs/ReleaseNotes.md b/amd/comgr/docs/ReleaseNotes.md
@@ -79,6 +79,10 @@ New APIs
     name expression). These calls assume that names of interest have been
     enclosed the HIP runtime using a stub attribute containg the following
     string in the name: "__amdgcn_name_expr".
+- amd\_comgr\_map\_elf\_virtual\_address\_to\_code\_object\_offset() (v2.7)
+    - For a given executable and ELF virtual address, return a code object
+    offset. This API will benifet the ROCm debugger and profilier
+
 
 Deprecated APIs
 ---------------
diff --git a/amd/comgr/include/amd_comgr.h.in b/amd/comgr/include/amd_comgr.h.in
@@ -216,6 +216,12 @@ extern "C" {
  */
 #define AMD_COMGR_VERSION_2_6
 
+/**
+ * The function was introduced or changed in version 2.7 of the interface
+ * and has the symbol version string of ``"@amd_comgr_NAME@_2.7"``.
+ */
+#define AMD_COMGR_VERSION_2_7
+
 /** @} */
 
 /**
@@ -2544,6 +2550,57 @@ amd_comgr_lookup_code_object(
     amd_comgr_code_object_info_t *info_list,
     size_t info_list_size) AMD_COMGR_VERSION_2_3;
 
+/**
+ * @ brief Given a code object and an ELF virtual address, map the ELF virtual
+ * address to a code object offset. Also, determine if the ELF virtual address
+ * maps to an offset in a data region that is defined by the ELF file, but that
+ * does not occupy bytes in the ELF file. This is typically true of offsets that
+ * that refer to runtime or heap allocated memory. For ELF files with defined
+ * sections, these data regions are referred to as NOBITS or .bss sections.
+ *
+ * @param[in] data The data object to be inspected for the given ELF virtual
+ * address. This should be of kind AMD_COMGR_DATA_KIND_EXECUTABLE.
+ *
+ * @param[in] elf_virtual_address The address used to calculate the code object
+ * offset.
+ *
+ * @param[out] code_object_offset The code object offset returned to the caller
+ * based on the given ELF virtual address.
+ *
+ * @param[out] slice_size For nobits regions: the size in bytes, starting from
+ * the provided virtual address up to the end of the segment. In this case, the
+ * slice size represents the number of contiguous unreadable addresses following
+ * the provided address.
+
+ * For bits regions: the size in bytes, starting from the provided virtual
+ * address up to either the end of the segment, or the start of a NOBITS region.
+ * In this case, slice size represents the number of contiguous readable
+ * addresses following the provided address.
+ *
+ * @param[out] nobits Set to true if the code object offset points to a location
+ * in a data region that does not occupy bytes in the ELF file, as described
+ * above.
+ *
+ * @retval ::AMD_COMGR_STATUS_SUCCESS The function has been executed
+ * successfully.
+ *
+ * @retval ::AMD_COMGR_STATUS_ERROR The provided code object has an invalid
+ * header due to a mismatch in magic, class, data, version, abi, type, or
+ * machine.
+ *
+ * @retval ::AMD_COMGR_STATUS_ERROR_INVALID_ARGUMENT @p data is not of
+ * kind AMD_COMGR_DATA_KIND_EXECUTABLE or invalid, or that the provided @p
+ * elf_virtual_address is not within the ranges covered by the object's
+ * load-type program headers.
+ */
+amd_comgr_status_t AMD_COMGR_API
+amd_comgr_map_elf_virtual_address_to_code_object_offset(
+    amd_comgr_data_t data,
+    uint64_t elf_virtual_address,
+    uint64_t *code_object_offset,
+    uint64_t *slice_size,
+    bool *nobits) AMD_COMGR_VERSION_2_7;
+
 /** @} */
 
 #ifdef __cplusplus
diff --git a/amd/comgr/src/comgr.cpp b/amd/comgr/src/comgr.cpp
@@ -2230,3 +2230,81 @@ amd_comgr_status_t AMD_COMGR_API
 
   return metadata::lookUpCodeObject(DataP, QueryList, QueryListSize);
 }
+
+amd_comgr_status_t AMD_COMGR_API
+// NOLINTNEXTLINE(readability-identifier-naming)
+amd_comgr_map_elf_virtual_address_to_code_object_offset(amd_comgr_data_t Data,
+                                       uint64_t ElfVirtualAddress,
+                                       uint64_t *CodeObjectOffset,
+                                       uint64_t *SliceSize,
+                                       bool *Nobits) {
+
+  DataObject *DataP = DataObject::convert(Data);
+  if (!DataP || !DataP->Data ||
+      (DataP->DataKind != AMD_COMGR_DATA_KIND_EXECUTABLE)) {
+    return AMD_COMGR_STATUS_ERROR_INVALID_ARGUMENT;
+  }
+
+  // Create ELF Object file
+  auto ELFFileOrError = llvm::object::ELF64LEFile::create(
+    StringRef(DataP->Data, DataP->Size));
+  if (!ELFFileOrError) {
+    llvm::logAllUnhandledErrors(ELFFileOrError.takeError(),
+                                llvm::errs(), "ELFObj creation error: ");
+    return AMD_COMGR_STATUS_ERROR;
+  }
+  auto ELFFile = std::move(ELFFileOrError.get());
+
+  // Error check the ELF file
+  auto ELFHeader = ELFFile.getHeader();
+  if (!ELFHeader.checkMagic())
+    return AMD_COMGR_STATUS_ERROR;
+
+  if (ELFHeader.e_ident[llvm::ELF::EI_CLASS] != llvm::ELF::ELFCLASS64 ||
+      ELFHeader.e_ident[llvm::ELF::EI_DATA] != llvm::ELF::ELFDATA2LSB ||
+      ELFHeader.e_ident[llvm::ELF::EI_VERSION] != llvm::ELF::EV_CURRENT ||
+      ELFHeader.e_ident[llvm::ELF::EI_OSABI] != llvm::ELF::ELFOSABI_AMDGPU_HSA)
+    return AMD_COMGR_STATUS_ERROR;
+
+  if (ELFHeader.e_ident[llvm::ELF::EI_ABIVERSION] !=
+      llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V4 &&
+      ELFHeader.e_ident[llvm::ELF::EI_ABIVERSION] !=
+      llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V5)
+    return AMD_COMGR_STATUS_ERROR;
+
+  if (ELFHeader.e_type != llvm::ELF::ET_DYN ||
+      ELFHeader.e_machine != llvm::ELF::EM_AMDGPU ||
+      ELFHeader.e_phoff == 0)
+    return AMD_COMGR_STATUS_ERROR;
+
+  // Access program headers
+  auto ProgHeadersOrError = ELFFile.program_headers();
+  if (!ProgHeadersOrError) {
+    llvm::logAllUnhandledErrors(ProgHeadersOrError.takeError(),
+                                llvm::errs(), "ProgHeaders creation error: ");
+    return AMD_COMGR_STATUS_ERROR;
+  }
+  auto ProgHeaders = std::move(ProgHeadersOrError.get());
+
+  for (auto phdr : ProgHeaders) {
+
+    // Check if ELF virtual address defined in this header
+    if (phdr.p_type == llvm::ELF::PT_LOAD &&
+        ElfVirtualAddress >= phdr.p_vaddr &&
+        ElfVirtualAddress < phdr.p_vaddr + phdr.p_memsz) {
+
+      *CodeObjectOffset = ElfVirtualAddress - phdr.p_vaddr + phdr.p_offset;
+      *Nobits = ElfVirtualAddress - phdr.p_vaddr >= phdr.p_filesz;
+
+      if (*Nobits) // end of segment to relative address difference
+        *SliceSize = phdr.p_filesz - (ElfVirtualAddress - phdr.p_vaddr);
+      else // end of valid memory to relative address difference
+        *SliceSize = phdr.p_memsz - (ElfVirtualAddress - phdr.p_vaddr);
+
+      return AMD_COMGR_STATUS_SUCCESS;
+    }
+  }
+
+  // If the provided ELF virtual address is not mapped to an offset
+  return AMD_COMGR_STATUS_ERROR_INVALID_ARGUMENT;
+}
diff --git a/amd/comgr/src/exportmap.in b/amd/comgr/src/exportmap.in
@@ -79,3 +79,7 @@ global: amd_comgr_populate_mangled_names;
 global: amd_comgr_populate_name_expression_map;
         amd_comgr_map_name_expression_to_symbol_name;
 } @amd_comgr_NAME@_2.5;
+
+@amd_comgr_NAME@_2.7 {
+global: amd_comgr_map_elf_virtual_address_to_code_object_offset;
+} @amd_comgr_NAME@_2.6;
diff --git a/amd/comgr/test/CMakeLists.txt b/amd/comgr/test/CMakeLists.txt
@@ -84,6 +84,8 @@ configure_file("source/source1.s" "source/source1.s" COPYONLY)
 configure_file("source/source1.hip" "source/source1.hip" COPYONLY)
 configure_file("source/source2.hip" "source/source2.hip" COPYONLY)
 configure_file("source/name-expression.hip" "source/name-expression.hip" COPYONLY)
+configure_file("source/rocm56slice.b" "source/rocm56slice.b" COPYONLY)
+configure_file("source/rocm57slice.b" "source/rocm57slice.b" COPYONLY)
 
 configure_file("source/square.hip" "source/square.hip" COPYONLY)
 configure_file("source/double.hip" "source/double.hip" COPYONLY)
@@ -177,6 +179,7 @@ add_comgr_test(mangled_names_test c)
 add_comgr_test(multithread_test cpp)
 add_comgr_test(name_expression_map_test c)
 add_comgr_test(nested_kernel_test c)
+add_comgr_test(map_elf_virtual_address_test c)
 
 # Test : Compile HIP tests only if HIP-Clang is installed.
 if (DEFINED HIP_COMPILER AND "${HIP_COMPILER}" STREQUAL "clang")
diff --git a/amd/comgr/test/map_elf_virtual_address_test.c b/amd/comgr/test/map_elf_virtual_address_test.c
diff --git a/amd/comgr/test/source/rocm56slice.b b/amd/comgr/test/source/rocm56slice.b
diff --git a/amd/comgr/test/source/rocm57slice.b b/amd/comgr/test/source/rocm57slice.b
