[libomptarget][amdgcn] Tolerate deadstripped device_state variable

[JonChesterfield]

Summary

[libomptarget][amdgcn] Tolerate deadstripped device_state variable

The device_state variable may have been deadstripped. Similar to
device_environment, leave detection of missing but used symbol to loader.

[pdhaliwal]

LGTM. Thanks!

openmp/libomptarget/plugins/amdgpu/src/rtl.cpp

 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <dlfcn.h>
 #include <elf.h>
 #include <ffi.h>
 #include <fstream>
 #include <iostream>
 #include <libelf.h>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <shared_mutex>
 #include <thread>
 #include <unordered_map>
 #include <vector>
 
if (!elf_machine_id_is_amdgcn(image)) {
     }
   }
 
   DP("ATMI module successfully loaded!\n");
 
   {
     // the device_State array is either large value in bss or a void* that
     // needs to be assigned to a pointer to an array of size device_state_bytes
+    // If absent, it has been deadstripped and needs no setup.
 
     void *state_ptr;
     uint32_t state_ptr_size;
     atmi_status_t err = atmi_interop_hsa_get_symbol_info(
         get_gpu_mem_place(device_id), "omptarget_nvptx_device_State",
         &state_ptr, &state_ptr_size);
 
     if (err != ATMI_STATUS_SUCCESS) {
-      fprintf(stderr, "failed to find device_state symbol\n");
-      return NULL;
-    }
-
+      DP("No device_state symbol found, skipping initialization\n");
+    } else {
       if (state_ptr_size < sizeof(void *)) {
-      fprintf(stderr, "unexpected size of state_ptr %u != %zu\n",
-              state_ptr_size, sizeof(void *));
+        DP("unexpected size of state_ptr %u != %zu\n", state_ptr_size,
+           sizeof(void *));
         return NULL;
       }
 
       // if it's larger than a void*, assume it's a bss array and no further
       // initialization is required. Only try to set up a pointer for
       // sizeof(void*)
       if (state_ptr_size == sizeof(void *)) {
         uint64_t device_State_bytes =
             get_device_State_bytes((char *)image->ImageStart, img_size);
         if (device_State_bytes == 0) {
+          DP("Can't initialize device_State, missing size information\n");
           return NULL;
         }
 
         auto &dss = DeviceInfo.deviceStateStore[device_id];
         if (dss.first.get() == nullptr) {
           assert(dss.second == 0);
           void *ptr = NULL;
-        atmi_status_t err =
-            atmi_calloc(&ptr, device_State_bytes, get_gpu_mem_place(device_id));
+          atmi_status_t err = atmi_calloc(&ptr, device_State_bytes,
+                                          get_gpu_mem_place(device_id));
           if (err != ATMI_STATUS_SUCCESS) {
-          fprintf(stderr, "Failed to allocate device_state array\n");
+            DP("Failed to allocate device_state array\n");
             return NULL;
           }
-        dss = {std::unique_ptr<void, RTLDeviceInfoTy::atmiFreePtrDeletor>{ptr},
-               device_State_bytes};
+          dss = {
+              std::unique_ptr<void, RTLDeviceInfoTy::atmiFreePtrDeletor>{ptr},
+              device_State_bytes,
+          };
         }
 
         void *ptr = dss.first.get();
         if (device_State_bytes != dss.second) {
-        fprintf(stderr, "Inconsistent sizes of device_State unsupported\n");
-        exit(1);
+          DP("Inconsistent sizes of device_State unsupported\n");
+          return NULL;
         }
 
         // write ptr to device memory so it can be used by later kernels
         err = DeviceInfo.freesignalpool_memcpy_h2d(state_ptr, &ptr,
                                                    sizeof(void *), device_id);
         if (err != ATMI_STATUS_SUCCESS) {
-        fprintf(stderr, "memcpy install of state_ptr failed\n");
+          DP("memcpy install of state_ptr failed\n");
           return NULL;
         }
       }
     }
+  }
 
   // Here, we take advantage of the data that is appended after img_end to get
   // the symbols' name we need to load. This data consist of the host entries
   // begin and end as well as the target name (see the offloading linker script
   // creation in clang compiler).
 
   // Find the symbols in the module by name. The name can be obtain by
   // concatenating the host entry name with the target name
if (e->size) {
 
       void *varptr;
       uint32_t varsize;
 
       atmi_status_t err = atmi_interop_hsa_get_symbol_info(
           get_gpu_mem_place(device_id), e->name, &varptr, &varsize);
 
       if (err != ATMI_STATUS_SUCCESS) {
-        DP("Loading global '%s' (Failed)\n", e->name);
         // Inform the user what symbol prevented offloading
-        fprintf(stderr, "Loading global '%s' (Failed)\n", e->name);
+        DP("Loading global '%s' (Failed)\n", e->name);
         return NULL;
       }
 
       if (varsize != e->size) {
         DP("Loading global '%s' - size mismatch (%u != %lu)\n", e->name,
            varsize, e->size);
         return NULL;
       }