[OpenMP][NFC] Clang format the libomptarget plugins

openmp/libomptarget/plugins/generic-elf-64bit/src/rtl.cpp

 //===-RTLs/generic-64bit/src/rtl.cpp - Target RTLs Implementation - C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // RTL for generic 64-bit machine
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include <cstdio>
-#include <cstring>
 #include <cstdlib>
+#include <cstring>
 #include <dlfcn.h>
 #include <ffi.h>
 #include <gelf.h>
 #include <link.h>
 #include <list>
 #include <string>
 #include <vector>
 
 #include "Debug.h"
 #include "omptargetplugin.h"
 
public:
   __tgt_target_table *getOffloadEntriesTable(int32_t device_id) {
     assert(device_id < (int32_t)FuncGblEntries.size() &&
            "Unexpected device id!");
     FuncOrGblEntryTy &E = FuncGblEntries[device_id].back();
 
     return &E.Table;
   }
 
-  RTLDeviceInfoTy(int32_t num_devices) {
-
-    FuncGblEntries.resize(num_devices);
-  }
+  RTLDeviceInfoTy(int32_t num_devices) { FuncGblEntries.resize(num_devices); }
 
   ~RTLDeviceInfoTy() {
     // Close dynamic libraries
     for (auto &lib : DynLibs) {
       if (lib.Handle) {
         dlclose(lib.Handle);
         remove(lib.FileName);
       }
__tgt_target_table *__tgt_rtl_load_binary(int32_t device_id,
 
   struct link_map *libInfo = (struct link_map *)Lib.Handle;
 
   // The place where the entries info is loaded is the library base address
   // plus the offset determined from the ELF file.
   Elf64_Addr entries_addr = libInfo->l_addr + entries_offset;
 
   DP("Pointer to first entry to be loaded is (" DPxMOD ").\n",
-      DPxPTR(entries_addr));
 
   // Table of pointers to all the entries in the target.
   __tgt_offload_entry *entries_table = (__tgt_offload_entry *)entries_addr;
 
   __tgt_offload_entry *entries_begin = &entries_table[0];
   __tgt_offload_entry *entries_end = entries_begin + NumEntries;
 
   if (!entries_begin) {
     DP("Can't obtain entries begin\n");
     elf_end(e);
     return NULL;
   }
 
   DP("Entries table range is (" DPxMOD ")->(" DPxMOD ")\n",
-      DPxPTR(entries_begin), DPxPTR(entries_end));
   DeviceInfo.createOffloadTable(device_id, entries_begin, entries_end);
 
   elf_end(e);
 
   return DeviceInfo.getOffloadEntriesTable(device_id);
 }
 
 void *__tgt_rtl_data_alloc(int32_t device_id, int64_t size, void *hst_ptr) {
int32_t __tgt_rtl_run_target_team_region(int32_t device_id, void *tgt_entry_ptr,
   assert(status == FFI_OK && "Unable to prepare target launch!");
 
   if (status != FFI_OK)
     return OFFLOAD_FAIL;
 
   DP("Running entry point at " DPxMOD "...\n", DPxPTR(tgt_entry_ptr));
 
   void (*entry)(void);
-  *((void**) &entry) = tgt_entry_ptr;
+  *((void **)&entry) = tgt_entry_ptr;
   ffi_call(&cif, entry, NULL, &args[0]);
   return OFFLOAD_SUCCESS;
 }
 
 int32_t __tgt_rtl_run_target_region(int32_t device_id, void *tgt_entry_ptr,
                                     void **tgt_args, ptrdiff_t *tgt_offsets,
                                     int32_t arg_num) {
   // use one team and one thread.
   return __tgt_rtl_run_target_team_region(device_id, tgt_entry_ptr, tgt_args,
                                           tgt_offsets, arg_num, 1, 1, 0);
 }
 
 #ifdef __cplusplus
 }
 #endif

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

 #include <algorithm>
 #include <cassert>
 #include <cerrno>
 #include <cstring>
 #include <list>
 #include <stdlib.h>
 #include <string>
 #include <sys/stat.h>
 #include <ve_offload.h>
 #include <vector>
 #include <veosinfo/veosinfo.h>
 
 #include "Debug.h"
 #include "omptargetplugin.h"
 
 #ifndef TARGET_NAME
 #define TARGET_NAME VE
for (__tgt_offload_entry *i = HostBegin; i != HostEnd; ++i) {
       __tgt_offload_entry Entry;
 
       if (!SymbolTargetAddr) {
         DP("Symbol %s not found in target image\n", SymbolName);
         Entry = {NULL, NULL, 0, 0, 0};
       } else {
         DP("Found symbol %s successfully in target image (addr: %p)\n",
            SymbolName, reinterpret_cast<void *>(SymbolTargetAddr));
-        Entry = { reinterpret_cast<void *>(SymbolTargetAddr),
-                  i->name,
-                  i->size,
-                  i->flags,
-                  0 };
+        Entry = {reinterpret_cast<void *>(SymbolTargetAddr), i->name, i->size,
+                 i->flags, 0};
       }
 
       T.push_back(Entry);
     }
 
     FuncOrGblEntry[device_id].back().Table.EntriesBegin = &T.front();
     FuncOrGblEntry[device_id].back().Table.EntriesEnd = &T.back() + 1;
   }
static int target_run_function_wait(uint32_t DeviceID, uint64_t FuncAddr,
   if (ret != 0) {
     DP("Waiting for entry point %p failed (Error code %d)\n",
        reinterpret_cast<void *>(FuncAddr), ret);
     return OFFLOAD_FAIL;
   }
   return OFFLOAD_SUCCESS;
 }
 
-
 // Return the number of available devices of the type supported by the
 // target RTL.
 int32_t __tgt_rtl_number_of_devices(void) { return DeviceInfo.NodeIds.size(); }
 
 // Return an integer different from zero if the provided device image can be
 // supported by the runtime. The functionality is similar to comparing the
 // result of __tgt__rtl__load__binary to NULL. However, this is meant to be a
 // lightweight query to determine if the RTL is suitable for an image without
if (DeviceInfo.ProcHandles[ID] == NULL) {
     DeviceInfo.ProcHandles[ID] = proc_handle;
     DP("Aurora device successfully initialized: proc_handle=%p", proc_handle);
   }
 
   ret = veo_alloc_mem(DeviceInfo.ProcHandles[ID], &addr, Size);
   DP("Allocate target memory: device=%d, target addr=%p, size=%" PRIu64 "\n",
      ID, reinterpret_cast<void *>(addr), Size);
   if (ret != 0) {
-    DP("veo_alloc_mem(%d, %p, %" PRIu64 ") failed with error code %d\n",
-       ID, reinterpret_cast<void *>(addr), Size, ret);
+    DP("veo_alloc_mem(%d, %p, %" PRIu64 ") failed with error code %d\n", ID,
+       reinterpret_cast<void *>(addr), Size, ret);
     return NULL;
   }
 
   return reinterpret_cast<void *>(addr);
 }
 
 // Pass the data content to the target device using the target address.
 // In case of success, return zero. Otherwise, return an error code.
if (ret != 0) {
     return OFFLOAD_FAIL;
   }
   return OFFLOAD_SUCCESS;
 }
 
 // De-allocate the data referenced by target ptr on the device. In case of
 // success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_delete(int32_t ID, void *TargetPtr) {
-  int ret =  veo_free_mem(DeviceInfo.ProcHandles[ID], (uint64_t)TargetPtr);
+  int ret = veo_free_mem(DeviceInfo.ProcHandles[ID], (uint64_t)TargetPtr);
 
   if (ret != 0) {
     DP("veo_free_mem() failed with error code %d\n", ret);
     return OFFLOAD_FAIL;
   }
   return OFFLOAD_SUCCESS;
 }
 
if (TargetArgs == NULL) {
     DP("Could not allocate VEO args\n");
     return OFFLOAD_FAIL;
   }
 
   for (int i = 0; i < NumArgs; ++i) {
     ret = veo_args_set_u64(TargetArgs, i, (intptr_t)Args[i]);
 
     if (ret != 0) {
-      DP("veo_args_set_u64() has returned %d for argnum=%d and value %p\n",
-         ret, i, Args[i]);
+      DP("veo_args_set_u64() has returned %d for argnum=%d and value %p\n", ret,
+         i, Args[i]);
       return OFFLOAD_FAIL;
     }
   }
 
   uint64_t RetVal;
   if (target_run_function_wait(ID, reinterpret_cast<uint64_t>(Entry),
                                TargetArgs, &RetVal) != OFFLOAD_SUCCESS) {
     veo_args_free(TargetArgs);