[libomptarget][amdgcn] Tolerate deadstripped env variable

[JonChesterfield]

Summary

[libomptarget][amdgcn] Tolerate deadstripped env variable

Discovered by Pushpinder. If the device_environment variable is unused
it can be deadstripped, in which case we should not abort due to it
missing. This change is safe in that a missing symbol which is actually
used can be reported by both linker and loader, and a missing unused
symbol is better deadstripped than left in the image.

[pdhaliwal]

LGTM, thanks for fixing it.

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>
 
struct device_environment {
   // rocmcc. Over time these differences will tend to zero and this class
   // simplified.
   // Symbol may be in .data or .bss, and may be missing fields:
   //  - aomp has debug_level, num_devices, device_num
   //  - trunk has debug_level
   //  - under review in trunk is debug_level, device_num
   //  - rocmcc matches aomp, patch to swap num_devices and device_num
 
+  // The symbol may also have been deadstripped because the device side
+  // accessors were unused.
+
   // If the symbol is in .data (aomp, rocm) it can be written directly.
   // If it is in .bss, we must wait for it to be allocated space on the
   // gpu (trunk) and initialize after loading.
   const char *sym() { return "omptarget_device_environment"; }
 
   omptarget_device_environmentTy host_device_env;
   symbol_info si;
   bool valid = false;
#endif
     }
 
     valid = true;
   }
 
   bool in_image() { return si.sh_type != SHT_NOBITS; }
 
   atmi_status_t before_loading(void *data, size_t size) {
-    assert(valid);
+    if (valid) {
       if (in_image()) {
-      DP("Setting global device environment before load (%u bytes)\n", si.size);
+        DP("Setting global device environment before load (%u bytes)\n",
+           si.size);
         uint64_t offset = (char *)si.addr - (char *)image->ImageStart;
         void *pos = (char *)data + offset;
         memcpy(pos, &host_device_env, si.size);
       }
+    }
     return ATMI_STATUS_SUCCESS;
   }
 
   atmi_status_t after_loading() {
-    assert(valid);
+    if (valid) {
       if (!in_image()) {
-      DP("Setting global device environment after load (%u bytes)\n", si.size);
+        DP("Setting global device environment after load (%u bytes)\n",
+           si.size);
         int device_id = host_device_env.device_num;
 
         void *state_ptr;
         uint32_t state_ptr_size;
         atmi_status_t err = atmi_interop_hsa_get_symbol_info(
             get_gpu_mem_place(device_id), sym(), &state_ptr, &state_ptr_size);
         if (err != ATMI_STATUS_SUCCESS) {
           DP("failed to find %s in loaded image\n", sym());
           return err;
         }
 
         if (state_ptr_size != si.size) {
           DP("Symbol had size %u before loading, %u after\n", state_ptr_size,
              si.size);
           return ATMI_STATUS_ERROR;
         }
 
         return DeviceInfo.freesignalpool_memcpy_h2d(state_ptr, &host_device_env,
                                                     state_ptr_size, device_id);
       }
+    }
     return ATMI_STATUS_SUCCESS;
   }
 };
 
 static atmi_status_t atmi_calloc(void **ret_ptr, size_t size,
                                  atmi_mem_place_t place) {
   uint64_t rounded = 4 * ((size + 3) / 4);
   void *ptr;
__tgt_target_table *__tgt_rtl_load_binary_locked(int32_t device_id,
 
   if (!elf_machine_id_is_amdgcn(image)) {
     return NULL;
   }
 
   {
     auto env = device_environment(device_id, DeviceInfo.NumberOfDevices, image,
                                   img_size);
-    if (!env.valid) {
-      return NULL;
-    }
 
     atmi_status_t err = module_register_from_memory_to_place(
         (void *)image->ImageStart, img_size, get_gpu_place(device_id),
         [&](void *data, size_t size) {
           return env.before_loading(data, size);
         });
 
     check("Module registering", err);