libgomp/target.c

   1 /* Copyright (C) 2013-2015 Free Software Foundation, Inc.
   2    Contributed by Jakub Jelinek <jakub@redhat.com>.
   3
   4    This file is part of the GNU Offloading and Multi Processing Library
   5    (libgomp).
   6
   7    Libgomp is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15    more details.
  16
  17    Under Section 7 of GPL version 3, you are granted additional
  18    permissions described in the GCC Runtime Library Exception, version
  19    3.1, as published by the Free Software Foundation.
  20
  21    You should have received a copy of the GNU General Public License and
  22    a copy of the GCC Runtime Library Exception along with this program;
  23    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24    <http://www.gnu.org/licenses/>.  */
  25
  26 /* This file contains the support of offloading.  */
  27
  28 #include "config.h"
  29 #include "libgomp.h"
  30 #include "oacc-plugin.h"
  31 #include "oacc-int.h"
  32 #include "gomp-constants.h"
  33 #include <limits.h>
  34 #include <stdbool.h>
  35 #include <stdlib.h>
  36 #ifdef HAVE_INTTYPES_H
  37 # include <inttypes.h>  /* For PRIu64.  */
  38 #endif
  39 #include <string.h>
  40 #include <assert.h>
  41 #include <errno.h>
  42
  43 #ifdef PLUGIN_SUPPORT
  44 #include <dlfcn.h>
  45 #include "plugin-suffix.h"
  46 #endif
  47
  48 static void gomp_target_init (void);
  49
  50 /* The whole initialization code for offloading plugins is only run one.  */
  51 static pthread_once_t gomp_is_initialized = PTHREAD_ONCE_INIT;
  52
  53 /* Mutex for offload image registration.  */
  54 static gomp_mutex_t register_lock;
  55
  56 /* This structure describes an offload image.
  57    It contains type of the target device, pointer to host table descriptor, and
  58    pointer to target data.  */
  59 struct offload_image_descr {
  60   unsigned version;
  61   enum offload_target_type type;
  62   const void *host_table;
  63   const void *target_data;
  64 };
  65
  66 /* Array of descriptors of offload images.  */
  67 static struct offload_image_descr *offload_images;
  68
  69 /* Total number of offload images.  */
  70 static int num_offload_images;
  71
  72 /* Array of descriptors for all available devices.  */
  73 static struct gomp_device_descr *devices;
  74
  75 /* Total number of available devices.  */
  76 static int num_devices;
  77
  78 /* Number of GOMP_OFFLOAD_CAP_OPENMP_400 devices.  */
  79 static int num_devices_openmp;
  80
  81 /* Similar to gomp_realloc, but release register_lock before gomp_fatal.  */
  82
  83 static void *
  84 gomp_realloc_unlock (void *old, size_t size)
  85 {
  86   void *ret = realloc (old, size);
  87   if (ret == NULL)
  88     {
  89       gomp_mutex_unlock (&register_lock);
  90       gomp_fatal ("Out of memory allocating %lu bytes", (unsigned long) size);
  91     }
  92   return ret;
  93 }
  94
  95 attribute_hidden void
  96 gomp_init_targets_once (void)
  97 {
  98   (void) pthread_once (&gomp_is_initialized, gomp_target_init);
  99 }
 100
 101 attribute_hidden int
 102 gomp_get_num_devices (void)
 103 {
 104   gomp_init_targets_once ();
 105   return num_devices_openmp;
 106 }
 107
 108 static struct gomp_device_descr *
 109 resolve_device (int device_id)
 110 {
 111   if (device_id == GOMP_DEVICE_ICV)
 112     {
 113       struct gomp_task_icv *icv = gomp_icv (false);
 114       device_id = icv->default_device_var;
 115     }
 116
 117   if (device_id < 0 || device_id >= gomp_get_num_devices ())
 118     return NULL;
 119
 120   gomp_mutex_lock (&devices[device_id].lock);
 121   if (devices[device_id].state == GOMP_DEVICE_UNINITIALIZED)
 122     gomp_init_device (&devices[device_id]);
 123   else if (devices[device_id].state == GOMP_DEVICE_FINALIZED)
 124     {
 125       gomp_mutex_unlock (&devices[device_id].lock);
 126       return NULL;
 127     }
 128   gomp_mutex_unlock (&devices[device_id].lock);
 129
 130   return &devices[device_id];
 131 }
 132
 133
 134 static inline splay_tree_key
 135 gomp_map_lookup (splay_tree mem_map, splay_tree_key key)
 136 {
 137   if (key->host_start != key->host_end)
 138     return splay_tree_lookup (mem_map, key);
 139
 140   key->host_end++;
 141   splay_tree_key n = splay_tree_lookup (mem_map, key);
 142   key->host_end--;
 143   if (n)
 144     return n;
 145   key->host_start--;
 146   n = splay_tree_lookup (mem_map, key);
 147   key->host_start++;
 148   if (n)
 149     return n;
 150   return splay_tree_lookup (mem_map, key);
 151 }
 152
 153 static inline splay_tree_key
 154 gomp_map_0len_lookup (splay_tree mem_map, splay_tree_key key)
 155 {
 156   if (key->host_start != key->host_end)
 157     return splay_tree_lookup (mem_map, key);
 158
 159   key->host_end++;
 160   splay_tree_key n = splay_tree_lookup (mem_map, key);
 161   key->host_end--;
 162   return n;
 163 }
 164
 165 /* Handle the case where gomp_map_lookup, splay_tree_lookup or
 166    gomp_map_0len_lookup found oldn for newn.
 167    Helper function of gomp_map_vars.  */
 168
 169 static inline void
 170 gomp_map_vars_existing (struct gomp_device_descr *devicep, splay_tree_key oldn,
 171                         splay_tree_key newn, struct target_var_desc *tgt_var,
 172                         unsigned char kind)
 173 {
 174   tgt_var->key = oldn;
 175   tgt_var->copy_from = GOMP_MAP_COPY_FROM_P (kind);
 176   tgt_var->always_copy_from = GOMP_MAP_ALWAYS_FROM_P (kind);
 177   tgt_var->offset = newn->host_start - oldn->host_start;
 178   tgt_var->length = newn->host_end - newn->host_start;
 179
 180   if ((kind & GOMP_MAP_FLAG_FORCE)
 181       || oldn->host_start > newn->host_start
 182       || oldn->host_end < newn->host_end)
 183     {
 184       gomp_mutex_unlock (&devicep->lock);
 185       gomp_fatal ("Trying to map into device [%p..%p) object when "
 186                   "[%p..%p) is already mapped",
 187                   (void *) newn->host_start, (void *) newn->host_end,
 188                   (void *) oldn->host_start, (void *) oldn->host_end);
 189     }
 190
 191   if (GOMP_MAP_ALWAYS_TO_P (kind))
 192     devicep->host2dev_func (devicep->target_id,
 193                             (void *) (oldn->tgt->tgt_start + oldn->tgt_offset
 194                                       + newn->host_start - oldn->host_start),
 195                             (void *) newn->host_start,
 196                             newn->host_end - newn->host_start);
 197   if (oldn->refcount != REFCOUNT_INFINITY)
 198     oldn->refcount++;
 199 }
 200
 201 static int
 202 get_kind (bool short_mapkind, void *kinds, int idx)
 203 {
 204   return short_mapkind ? ((unsigned short *) kinds)[idx]
 205                        : ((unsigned char *) kinds)[idx];
 206 }
 207
 208 static void
 209 gomp_map_pointer (struct target_mem_desc *tgt, uintptr_t host_ptr,
 210                   uintptr_t target_offset, uintptr_t bias)
 211 {
 212   struct gomp_device_descr *devicep = tgt->device_descr;
 213   struct splay_tree_s *mem_map = &devicep->mem_map;
 214   struct splay_tree_key_s cur_node;
 215
 216   cur_node.host_start = host_ptr;
 217   if (cur_node.host_start == (uintptr_t) NULL)
 218     {
 219       cur_node.tgt_offset = (uintptr_t) NULL;
 220       /* FIXME: see comment about coalescing host/dev transfers below.  */
 221       devicep->host2dev_func (devicep->target_id,
 222                               (void *) (tgt->tgt_start + target_offset),
 223                               (void *) &cur_node.tgt_offset,
 224                               sizeof (void *));
 225       return;
 226     }
 227   /* Add bias to the pointer value.  */
 228   cur_node.host_start += bias;
 229   cur_node.host_end = cur_node.host_start;
 230   splay_tree_key n = gomp_map_lookup (mem_map, &cur_node);
 231   if (n == NULL)
 232     {
 233       gomp_mutex_unlock (&devicep->lock);
 234       gomp_fatal ("Pointer target of array section wasn't mapped");
 235     }
 236   cur_node.host_start -= n->host_start;
 237   cur_node.tgt_offset
 238     = n->tgt->tgt_start + n->tgt_offset + cur_node.host_start;
 239   /* At this point tgt_offset is target address of the
 240      array section.  Now subtract bias to get what we want
 241      to initialize the pointer with.  */
 242   cur_node.tgt_offset -= bias;
 243   /* FIXME: see comment about coalescing host/dev transfers below.  */
 244   devicep->host2dev_func (devicep->target_id,
 245                           (void *) (tgt->tgt_start + target_offset),
 246                           (void *) &cur_node.tgt_offset,
 247                           sizeof (void *));
 248 }
 249
 250 static void
 251 gomp_map_fields_existing (struct target_mem_desc *tgt, splay_tree_key n,
 252                           size_t first, size_t i, void **hostaddrs,
 253                           size_t *sizes, void *kinds)
 254 {
 255   struct gomp_device_descr *devicep = tgt->device_descr;
 256   struct splay_tree_s *mem_map = &devicep->mem_map;
 257   struct splay_tree_key_s cur_node;
 258   int kind;
 259   const bool short_mapkind = true;
 260   const int typemask = short_mapkind ? 0xff : 0x7;
 261
 262   cur_node.host_start = (uintptr_t) hostaddrs[i];
 263   cur_node.host_end = cur_node.host_start + sizes[i];
 264   splay_tree_key n2 = splay_tree_lookup (mem_map, &cur_node);
 265   kind = get_kind (short_mapkind, kinds, i);
 266   if (n2
 267       && n2->tgt == n->tgt
 268       && n2->host_start - n->host_start == n2->tgt_offset - n->tgt_offset)
 269     {
 270       gomp_map_vars_existing (devicep, n2, &cur_node,
 271                               &tgt->list[i], kind & typemask);
 272       return;
 273     }
 274   if (sizes[i] == 0)
 275     {
 276       if (cur_node.host_start > (uintptr_t) hostaddrs[first - 1])
 277         {
 278           cur_node.host_start--;
 279           n2 = splay_tree_lookup (mem_map, &cur_node);
 280           cur_node.host_start++;
 281           if (n2
 282               && n2->tgt == n->tgt
 283               && n2->host_start - n->host_start
 284                  == n2->tgt_offset - n->tgt_offset)
 285             {
 286               gomp_map_vars_existing (devicep, n2, &cur_node, &tgt->list[i],
 287                                       kind & typemask);
 288               return;
 289             }
 290         }
 291       cur_node.host_end++;
 292       n2 = splay_tree_lookup (mem_map, &cur_node);
 293       cur_node.host_end--;
 294       if (n2
 295           && n2->tgt == n->tgt
 296           && n2->host_start - n->host_start == n2->tgt_offset - n->tgt_offset)
 297         {
 298           gomp_map_vars_existing (devicep, n2, &cur_node, &tgt->list[i],
 299                                   kind & typemask);
 300           return;
 301         }
 302     }
 303   gomp_mutex_unlock (&devicep->lock);
 304   gomp_fatal ("Trying to map into device [%p..%p) structure element when "
 305               "other mapped elements from the same structure weren't mapped "
 306               "together with it", (void *) cur_node.host_start,
 307               (void *) cur_node.host_end);
 308 }
 309
 310 static inline uintptr_t
 311 gomp_map_val (struct target_mem_desc *tgt, void **hostaddrs, size_t i)
 312 {
 313   if (tgt->list[i].key != NULL)
 314     return tgt->list[i].key->tgt->tgt_start
 315            + tgt->list[i].key->tgt_offset
 316            + tgt->list[i].offset;
 317   if (tgt->list[i].offset == ~(uintptr_t) 0)
 318     return (uintptr_t) hostaddrs[i];
 319   if (tgt->list[i].offset == ~(uintptr_t) 1)
 320     return 0;
 321   if (tgt->list[i].offset == ~(uintptr_t) 2)
 322     return tgt->list[i + 1].key->tgt->tgt_start
 323            + tgt->list[i + 1].key->tgt_offset
 324            + tgt->list[i + 1].offset
 325            + (uintptr_t) hostaddrs[i]
 326            - (uintptr_t) hostaddrs[i + 1];
 327   return tgt->tgt_start + tgt->list[i].offset;
 328 }
 329
 330 attribute_hidden struct target_mem_desc *
 331 gomp_map_vars (struct gomp_device_descr *devicep, size_t mapnum,
 332                void **hostaddrs, void **devaddrs, size_t *sizes, void *kinds,
 333                bool short_mapkind, enum gomp_map_vars_kind pragma_kind)
 334 {
 335   size_t i, tgt_align, tgt_size, not_found_cnt = 0;
 336   bool has_firstprivate = false;
 337   const int rshift = short_mapkind ? 8 : 3;
 338   const int typemask = short_mapkind ? 0xff : 0x7;
 339   struct splay_tree_s *mem_map = &devicep->mem_map;
 340   struct splay_tree_key_s cur_node;
 341   struct target_mem_desc *tgt
 342     = gomp_malloc (sizeof (*tgt) + sizeof (tgt->list[0]) * mapnum);
 343   tgt->list_count = mapnum;
 344   tgt->refcount = pragma_kind == GOMP_MAP_VARS_ENTER_DATA ? 0 : 1;
 345   tgt->device_descr = devicep;
 346
 347   if (mapnum == 0)
 348     {
 349       tgt->tgt_start = 0;
 350       tgt->tgt_end = 0;
 351       return tgt;
 352     }
 353
 354   tgt_align = sizeof (void *);
 355   tgt_size = 0;
 356   if (pragma_kind == GOMP_MAP_VARS_TARGET)
 357     {
 358       size_t align = 4 * sizeof (void *);
 359       tgt_align = align;
 360       tgt_size = mapnum * sizeof (void *);
 361     }
 362
 363   gomp_mutex_lock (&devicep->lock);
 364   if (devicep->state == GOMP_DEVICE_FINALIZED)
 365     {
 366       gomp_mutex_unlock (&devicep->lock);
 367       free (tgt);
 368       return NULL;
 369     }
 370
 371   for (i = 0; i < mapnum; i++)
 372     {
 373       int kind = get_kind (short_mapkind, kinds, i);
 374       if (hostaddrs[i] == NULL
 375           || (kind & typemask) == GOMP_MAP_FIRSTPRIVATE_INT)
 376         {
 377           tgt->list[i].key = NULL;
 378           tgt->list[i].offset = ~(uintptr_t) 0;
 379           continue;
 380         }
 381       else if ((kind & typemask) == GOMP_MAP_USE_DEVICE_PTR)
 382         {
 383           cur_node.host_start = (uintptr_t) hostaddrs[i];
 384           cur_node.host_end = cur_node.host_start;
 385           splay_tree_key n = gomp_map_lookup (mem_map, &cur_node);
 386           if (n == NULL)
 387             {
 388               gomp_mutex_unlock (&devicep->lock);
 389               gomp_fatal ("use_device_ptr pointer wasn't mapped");
 390             }
 391           cur_node.host_start -= n->host_start;
 392           hostaddrs[i]
 393             = (void *) (n->tgt->tgt_start + n->tgt_offset
 394                         + cur_node.host_start);
 395           tgt->list[i].key = NULL;
 396           tgt->list[i].offset = ~(uintptr_t) 0;
 397           continue;
 398         }
 399       else if ((kind & typemask) == GOMP_MAP_STRUCT)
 400         {
 401           size_t first = i + 1;
 402           size_t last = i + sizes[i];
 403           cur_node.host_start = (uintptr_t) hostaddrs[i];
 404           cur_node.host_end = (uintptr_t) hostaddrs[last]
 405                               + sizes[last];
 406           tgt->list[i].key = NULL;
 407           tgt->list[i].offset = ~(uintptr_t) 2;
 408           splay_tree_key n = splay_tree_lookup (mem_map, &cur_node);
 409           if (n == NULL)
 410             {
 411               size_t align = (size_t) 1 << (kind >> rshift);
 412               if (tgt_align < align)
 413                 tgt_align = align;
 414               tgt_size -= (uintptr_t) hostaddrs[first]
 415                           - (uintptr_t) hostaddrs[i];
 416               tgt_size = (tgt_size + align - 1) & ~(align - 1);
 417               tgt_size += cur_node.host_end - (uintptr_t) hostaddrs[i];
 418               not_found_cnt += last - i;
 419               for (i = first; i <= last; i++)
 420                 tgt->list[i].key = NULL;
 421               i--;
 422               continue;
 423             }
 424           for (i = first; i <= last; i++)
 425             gomp_map_fields_existing (tgt, n, first, i, hostaddrs,
 426                                       sizes, kinds);
 427           i--;
 428           continue;
 429         }
 430       else if ((kind & typemask) == GOMP_MAP_ALWAYS_POINTER)
 431         {
 432           tgt->list[i].key = NULL;
 433           tgt->list[i].offset = ~(uintptr_t) 1;
 434           has_firstprivate = true;
 435           continue;
 436         }
 437       cur_node.host_start = (uintptr_t) hostaddrs[i];
 438       if (!GOMP_MAP_POINTER_P (kind & typemask))
 439         cur_node.host_end = cur_node.host_start + sizes[i];
 440       else
 441         cur_node.host_end = cur_node.host_start + sizeof (void *);
 442       if ((kind & typemask) == GOMP_MAP_FIRSTPRIVATE)
 443         {
 444           tgt->list[i].key = NULL;
 445
 446           size_t align = (size_t) 1 << (kind >> rshift);
 447           if (tgt_align < align)
 448             tgt_align = align;
 449           tgt_size = (tgt_size + align - 1) & ~(align - 1);
 450           tgt_size += cur_node.host_end - cur_node.host_start;
 451           has_firstprivate = true;
 452           continue;
 453         }
 454       splay_tree_key n;
 455       if ((kind & typemask) == GOMP_MAP_ZERO_LEN_ARRAY_SECTION)
 456         {
 457           n = gomp_map_0len_lookup (mem_map, &cur_node);
 458           if (!n)
 459             {
 460               tgt->list[i].key = NULL;
 461               tgt->list[i].offset = ~(uintptr_t) 1;
 462               continue;
 463             }
 464         }
 465       else
 466         n = splay_tree_lookup (mem_map, &cur_node);
 467       if (n && n->refcount != REFCOUNT_LINK)
 468         gomp_map_vars_existing (devicep, n, &cur_node, &tgt->list[i],
 469                                 kind & typemask);
 470       else
 471         {
 472           tgt->list[i].key = NULL;
 473
 474           size_t align = (size_t) 1 << (kind >> rshift);
 475           not_found_cnt++;
 476           if (tgt_align < align)
 477             tgt_align = align;
 478           tgt_size = (tgt_size + align - 1) & ~(align - 1);
 479           tgt_size += cur_node.host_end - cur_node.host_start;
 480           if ((kind & typemask) == GOMP_MAP_TO_PSET)
 481             {
 482               size_t j;
 483               for (j = i + 1; j < mapnum; j++)
 484                 if (!GOMP_MAP_POINTER_P (get_kind (short_mapkind, kinds, j)
 485                                          & typemask))
 486                   break;
 487                 else if ((uintptr_t) hostaddrs[j] < cur_node.host_start
 488                          || ((uintptr_t) hostaddrs[j] + sizeof (void *)
 489                              > cur_node.host_end))
 490                   break;
 491                 else
 492                   {
 493                     tgt->list[j].key = NULL;
 494                     i++;
 495                   }
 496             }
 497         }
 498     }
 499
 500   if (devaddrs)
 501     {
 502       if (mapnum != 1)
 503         {
 504           gomp_mutex_unlock (&devicep->lock);
 505           gomp_fatal ("unexpected aggregation");
 506         }
 507       tgt->to_free = devaddrs[0];
 508       tgt->tgt_start = (uintptr_t) tgt->to_free;
 509       tgt->tgt_end = tgt->tgt_start + sizes[0];
 510     }
 511   else if (not_found_cnt || pragma_kind == GOMP_MAP_VARS_TARGET)
 512     {
 513       /* Allocate tgt_align aligned tgt_size block of memory.  */
 514       /* FIXME: Perhaps change interface to allocate properly aligned
 515          memory.  */
 516       tgt->to_free = devicep->alloc_func (devicep->target_id,
 517                                           tgt_size + tgt_align - 1);
 518       tgt->tgt_start = (uintptr_t) tgt->to_free;
 519       tgt->tgt_start = (tgt->tgt_start + tgt_align - 1) & ~(tgt_align - 1);
 520       tgt->tgt_end = tgt->tgt_start + tgt_size;
 521     }
 522   else
 523     {
 524       tgt->to_free = NULL;
 525       tgt->tgt_start = 0;
 526       tgt->tgt_end = 0;
 527     }
 528
 529   tgt_size = 0;
 530   if (pragma_kind == GOMP_MAP_VARS_TARGET)
 531     tgt_size = mapnum * sizeof (void *);
 532
 533   tgt->array = NULL;
 534   if (not_found_cnt || has_firstprivate)
 535     {
 536       if (not_found_cnt)
 537         tgt->array = gomp_malloc (not_found_cnt * sizeof (*tgt->array));
 538       splay_tree_node array = tgt->array;
 539       size_t j, field_tgt_offset = 0, field_tgt_clear = ~(size_t) 0;
 540       uintptr_t field_tgt_base = 0;
 541
 542       for (i = 0; i < mapnum; i++)
 543         if (tgt->list[i].key == NULL)
 544           {
 545             int kind = get_kind (short_mapkind, kinds, i);
 546             if (hostaddrs[i] == NULL)
 547               continue;
 548             switch (kind & typemask)
 549               {
 550                 size_t align, len, first, last;
 551                 splay_tree_key n;
 552               case GOMP_MAP_FIRSTPRIVATE:
 553                 align = (size_t) 1 << (kind >> rshift);
 554                 tgt_size = (tgt_size + align - 1) & ~(align - 1);
 555                 tgt->list[i].offset = tgt_size;
 556                 len = sizes[i];
 557                 devicep->host2dev_func (devicep->target_id,
 558                                         (void *) (tgt->tgt_start + tgt_size),
 559                                         (void *) hostaddrs[i], len);
 560                 tgt_size += len;
 561                 continue;
 562               case GOMP_MAP_FIRSTPRIVATE_INT:
 563               case GOMP_MAP_USE_DEVICE_PTR:
 564               case GOMP_MAP_ZERO_LEN_ARRAY_SECTION:
 565                 continue;
 566               case GOMP_MAP_STRUCT:
 567                 first = i + 1;
 568                 last = i + sizes[i];
 569                 cur_node.host_start = (uintptr_t) hostaddrs[i];
 570                 cur_node.host_end = (uintptr_t) hostaddrs[last]
 571                                     + sizes[last];
 572                 if (tgt->list[first].key != NULL)
 573                   continue;
 574                 n = splay_tree_lookup (mem_map, &cur_node);
 575                 if (n == NULL)
 576                   {
 577                     size_t align = (size_t) 1 << (kind >> rshift);
 578                     tgt_size -= (uintptr_t) hostaddrs[first]
 579                                 - (uintptr_t) hostaddrs[i];
 580                     tgt_size = (tgt_size + align - 1) & ~(align - 1);
 581                     tgt_size += (uintptr_t) hostaddrs[first]
 582                                 - (uintptr_t) hostaddrs[i];
 583                     field_tgt_base = (uintptr_t) hostaddrs[first];
 584                     field_tgt_offset = tgt_size;
 585                     field_tgt_clear = last;
 586                     tgt_size += cur_node.host_end
 587                                 - (uintptr_t) hostaddrs[first];
 588                     continue;
 589                   }
 590                 for (i = first; i <= last; i++)
 591                   gomp_map_fields_existing (tgt, n, first, i, hostaddrs,
 592                                             sizes, kinds);
 593                 i--;
 594                 continue;
 595               case GOMP_MAP_ALWAYS_POINTER:
 596                 cur_node.host_start = (uintptr_t) hostaddrs[i];
 597                 cur_node.host_end = cur_node.host_start + sizeof (void *);
 598                 n = splay_tree_lookup (mem_map, &cur_node);
 599                 if (n == NULL
 600                     || n->host_start > cur_node.host_start
 601                     || n->host_end < cur_node.host_end)
 602                   {
 603                     gomp_mutex_unlock (&devicep->lock);
 604                     gomp_fatal ("always pointer not mapped");
 605                   }
 606                 if ((get_kind (short_mapkind, kinds, i - 1) & typemask)
 607                     != GOMP_MAP_ALWAYS_POINTER)
 608                   cur_node.tgt_offset = gomp_map_val (tgt, hostaddrs, i - 1);
 609                 if (cur_node.tgt_offset)
 610                   cur_node.tgt_offset -= sizes[i];
 611                 devicep->host2dev_func (devicep->target_id,
 612                                         (void *) (n->tgt->tgt_start
 613                                                   + n->tgt_offset
 614                                                   + cur_node.host_start
 615                                                   - n->host_start),
 616                                         (void *) &cur_node.tgt_offset,
 617                                         sizeof (void *));
 618                 cur_node.tgt_offset = n->tgt->tgt_start + n->tgt_offset
 619                                       + cur_node.host_start - n->host_start;
 620                 continue;
 621               default:
 622                 break;
 623               }
 624             splay_tree_key k = &array->key;
 625             k->host_start = (uintptr_t) hostaddrs[i];
 626             if (!GOMP_MAP_POINTER_P (kind & typemask))
 627               k->host_end = k->host_start + sizes[i];
 628             else
 629               k->host_end = k->host_start + sizeof (void *);
 630             splay_tree_key n = splay_tree_lookup (mem_map, k);
 631             if (n && n->refcount != REFCOUNT_LINK)
 632               gomp_map_vars_existing (devicep, n, k, &tgt->list[i],
 633                                       kind & typemask);
 634             else
 635               {
 636                 k->link_key = NULL;
 637                 if (n && n->refcount == REFCOUNT_LINK)
 638                   {
 639                     /* Replace target address of the pointer with target address
 640                        of mapped object in the splay tree.  */
 641                     splay_tree_remove (mem_map, n);
 642                     k->link_key = n;
 643                   }
 644                 size_t align = (size_t) 1 << (kind >> rshift);
 645                 tgt->list[i].key = k;
 646                 k->tgt = tgt;
 647                 if (field_tgt_clear != ~(size_t) 0)
 648                   {
 649                     k->tgt_offset = k->host_start - field_tgt_base
 650                                     + field_tgt_offset;
 651                     if (i == field_tgt_clear)
 652                       field_tgt_clear = ~(size_t) 0;
 653                   }
 654                 else
 655                   {
 656                     tgt_size = (tgt_size + align - 1) & ~(align - 1);
 657                     k->tgt_offset = tgt_size;
 658                     tgt_size += k->host_end - k->host_start;
 659                   }
 660                 tgt->list[i].copy_from = GOMP_MAP_COPY_FROM_P (kind & typemask);
 661                 tgt->list[i].always_copy_from
 662                   = GOMP_MAP_ALWAYS_FROM_P (kind & typemask);
 663                 tgt->list[i].offset = 0;
 664                 tgt->list[i].length = k->host_end - k->host_start;
 665                 k->refcount = 1;
 666                 k->async_refcount = 0;
 667                 tgt->refcount++;
 668                 array->left = NULL;
 669                 array->right = NULL;
 670                 splay_tree_insert (mem_map, array);
 671                 switch (kind & typemask)
 672                   {
 673                   case GOMP_MAP_ALLOC:
 674                   case GOMP_MAP_FROM:
 675                   case GOMP_MAP_FORCE_ALLOC:
 676                   case GOMP_MAP_FORCE_FROM:
 677                   case GOMP_MAP_ALWAYS_FROM:
 678                     break;
 679                   case GOMP_MAP_TO:
 680                   case GOMP_MAP_TOFROM:
 681                   case GOMP_MAP_FORCE_TO:
 682                   case GOMP_MAP_FORCE_TOFROM:
 683                   case GOMP_MAP_ALWAYS_TO:
 684                   case GOMP_MAP_ALWAYS_TOFROM:
 685                     /* FIXME: Perhaps add some smarts, like if copying
 686                        several adjacent fields from host to target, use some
 687                        host buffer to avoid sending each var individually.  */
 688                     devicep->host2dev_func (devicep->target_id,
 689                                             (void *) (tgt->tgt_start
 690                                                       + k->tgt_offset),
 691                                             (void *) k->host_start,
 692                                             k->host_end - k->host_start);
 693                     break;
 694                   case GOMP_MAP_POINTER:
 695                     gomp_map_pointer (tgt, (uintptr_t) *(void **) k->host_start,
 696                                       k->tgt_offset, sizes[i]);
 697                     break;
 698                   case GOMP_MAP_TO_PSET:
 699                     /* FIXME: see above FIXME comment.  */
 700                     devicep->host2dev_func (devicep->target_id,
 701                                             (void *) (tgt->tgt_start
 702                                                       + k->tgt_offset),
 703                                             (void *) k->host_start,
 704                                             k->host_end - k->host_start);
 705
 706                     for (j = i + 1; j < mapnum; j++)
 707                       if (!GOMP_MAP_POINTER_P (get_kind (short_mapkind, kinds,
 708                                                          j)
 709                                                & typemask))
 710                         break;
 711                       else if ((uintptr_t) hostaddrs[j] < k->host_start
 712                                || ((uintptr_t) hostaddrs[j] + sizeof (void *)
 713                                    > k->host_end))
 714                         break;
 715                       else
 716                         {
 717                           tgt->list[j].key = k;
 718                           tgt->list[j].copy_from = false;
 719                           tgt->list[j].always_copy_from = false;
 720                           if (k->refcount != REFCOUNT_INFINITY)
 721                             k->refcount++;
 722                           gomp_map_pointer (tgt,
 723                                             (uintptr_t) *(void **) hostaddrs[j],
 724                                             k->tgt_offset
 725                                             + ((uintptr_t) hostaddrs[j]
 726                                                - k->host_start),
 727                                             sizes[j]);
 728                           i++;
 729                         }
 730                     break;
 731                   case GOMP_MAP_FORCE_PRESENT:
 732                     {
 733                       /* We already looked up the memory region above and it
 734                          was missing.  */
 735                       size_t size = k->host_end - k->host_start;
 736                       gomp_mutex_unlock (&devicep->lock);
 737 #ifdef HAVE_INTTYPES_H
 738                       gomp_fatal ("present clause: !acc_is_present (%p, "
 739                                   "%"PRIu64" (0x%"PRIx64"))",
 740                                   (void *) k->host_start,
 741                                   (uint64_t) size, (uint64_t) size);
 742 #else
 743                       gomp_fatal ("present clause: !acc_is_present (%p, "
 744                                   "%lu (0x%lx))", (void *) k->host_start,
 745                                   (unsigned long) size, (unsigned long) size);
 746 #endif
 747                     }
 748                     break;
 749                   case GOMP_MAP_FORCE_DEVICEPTR:
 750                     assert (k->host_end - k->host_start == sizeof (void *));
 751
 752                     devicep->host2dev_func (devicep->target_id,
 753                                             (void *) (tgt->tgt_start
 754                                                       + k->tgt_offset),
 755                                             (void *) k->host_start,
 756                                             sizeof (void *));
 757                     break;
 758                   default:
 759                     gomp_mutex_unlock (&devicep->lock);
 760                     gomp_fatal ("%s: unhandled kind 0x%.2x", __FUNCTION__,
 761                                 kind);
 762                   }
 763
 764                 if (k->link_key)
 765                   {
 766                     /* Set link pointer on target to the device address of the
 767                        mapped object.  */
 768                     void *tgt_addr = (void *) (tgt->tgt_start + k->tgt_offset);
 769                     devicep->host2dev_func (devicep->target_id,
 770                                             (void *) n->tgt_offset,
 771                                             &tgt_addr, sizeof (void *));
 772                   }
 773                 array++;
 774               }
 775           }
 776     }
 777
 778   if (pragma_kind == GOMP_MAP_VARS_TARGET)
 779     {
 780       for (i = 0; i < mapnum; i++)
 781         {
 782           cur_node.tgt_offset = gomp_map_val (tgt, hostaddrs, i);
 783           /* FIXME: see above FIXME comment.  */
 784           devicep->host2dev_func (devicep->target_id,
 785                                   (void *) (tgt->tgt_start
 786                                             + i * sizeof (void *)),
 787                                   (void *) &cur_node.tgt_offset,
 788                                   sizeof (void *));
 789         }
 790     }
 791
 792   /* If the variable from "omp target enter data" map-list was already mapped,
 793      tgt is not needed.  Otherwise tgt will be freed by gomp_unmap_vars or
 794      gomp_exit_data.  */
 795   if (pragma_kind == GOMP_MAP_VARS_ENTER_DATA && tgt->refcount == 0)
 796     {
 797       free (tgt);
 798       tgt = NULL;
 799     }
 800
 801   gomp_mutex_unlock (&devicep->lock);
 802   return tgt;
 803 }
 804
 805 static void
 806 gomp_unmap_tgt (struct target_mem_desc *tgt)
 807 {
 808   /* Deallocate on target the tgt->tgt_start .. tgt->tgt_end region.  */
 809   if (tgt->tgt_end)
 810     tgt->device_descr->free_func (tgt->device_descr->target_id, tgt->to_free);
 811
 812   free (tgt->array);
 813   free (tgt);
 814 }
 815
 816 /* Decrease the refcount for a set of mapped variables, and queue asychronous
 817    copies from the device back to the host after any work that has been issued.
 818    Because the regions are still "live", increment an asynchronous reference
 819    count to indicate that they should not be unmapped from host-side data
 820    structures until the asynchronous copy has completed.  */
 821
 822 attribute_hidden void
 823 gomp_copy_from_async (struct target_mem_desc *tgt)
 824 {
 825   struct gomp_device_descr *devicep = tgt->device_descr;
 826   size_t i;
 827
 828   gomp_mutex_lock (&devicep->lock);
 829
 830   for (i = 0; i < tgt->list_count; i++)
 831     if (tgt->list[i].key == NULL)
 832       ;
 833     else if (tgt->list[i].key->refcount > 1)
 834       {
 835         tgt->list[i].key->refcount--;
 836         tgt->list[i].key->async_refcount++;
 837       }
 838     else
 839       {
 840         splay_tree_key k = tgt->list[i].key;
 841         if (tgt->list[i].copy_from)
 842           devicep->dev2host_func (devicep->target_id, (void *) k->host_start,
 843                                   (void *) (k->tgt->tgt_start + k->tgt_offset),
 844                                   k->host_end - k->host_start);
 845       }
 846
 847   gomp_mutex_unlock (&devicep->lock);
 848 }
 849
 850 /* Unmap variables described by TGT.  If DO_COPYFROM is true, copy relevant
 851    variables back from device to host: if it is false, it is assumed that this
 852    has been done already, i.e. by gomp_copy_from_async above.  */
 853
 854 attribute_hidden void
 855 gomp_unmap_vars (struct target_mem_desc *tgt, bool do_copyfrom)
 856 {
 857   struct gomp_device_descr *devicep = tgt->device_descr;
 858
 859   if (tgt->list_count == 0)
 860     {
 861       free (tgt);
 862       return;
 863     }
 864
 865   gomp_mutex_lock (&devicep->lock);
 866   if (devicep->state == GOMP_DEVICE_FINALIZED)
 867     {
 868       gomp_mutex_unlock (&devicep->lock);
 869       free (tgt->array);
 870       free (tgt);
 871       return;
 872     }
 873
 874   size_t i;
 875   for (i = 0; i < tgt->list_count; i++)
 876     {
 877       splay_tree_key k = tgt->list[i].key;
 878       if (k == NULL)
 879         continue;
 880
 881       bool do_unmap = false;
 882       if (k->refcount > 1 && k->refcount != REFCOUNT_INFINITY)
 883         k->refcount--;
 884       else if (k->refcount == 1)
 885         {
 886           if (k->async_refcount > 0)
 887             k->async_refcount--;
 888           else
 889             {
 890               k->refcount--;
 891               do_unmap = true;
 892             }
 893         }
 894
 895       if ((do_unmap && do_copyfrom && tgt->list[i].copy_from)
 896           || tgt->list[i].always_copy_from)
 897         devicep->dev2host_func (devicep->target_id,
 898                                 (void *) (k->host_start + tgt->list[i].offset),
 899                                 (void *) (k->tgt->tgt_start + k->tgt_offset
 900                                           + tgt->list[i].offset),
 901                                 tgt->list[i].length);
 902       if (do_unmap)
 903         {
 904           splay_tree_remove (&devicep->mem_map, k);
 905           if (k->link_key)
 906             splay_tree_insert (&devicep->mem_map,
 907                                (splay_tree_node) k->link_key);
 908           if (k->tgt->refcount > 1)
 909             k->tgt->refcount--;
 910           else
 911             gomp_unmap_tgt (k->tgt);
 912         }
 913     }
 914
 915   if (tgt->refcount > 1)
 916     tgt->refcount--;
 917   else
 918     gomp_unmap_tgt (tgt);
 919
 920   gomp_mutex_unlock (&devicep->lock);
 921 }
 922
 923 static void
 924 gomp_update (struct gomp_device_descr *devicep, size_t mapnum, void **hostaddrs,
 925              size_t *sizes, void *kinds, bool short_mapkind)
 926 {
 927   size_t i;
 928   struct splay_tree_key_s cur_node;
 929   const int typemask = short_mapkind ? 0xff : 0x7;
 930
 931   if (!devicep)
 932     return;
 933
 934   if (mapnum == 0)
 935     return;
 936
 937   gomp_mutex_lock (&devicep->lock);
 938   if (devicep->state == GOMP_DEVICE_FINALIZED)
 939     {
 940       gomp_mutex_unlock (&devicep->lock);
 941       return;
 942     }
 943
 944   for (i = 0; i < mapnum; i++)
 945     if (sizes[i])
 946       {
 947         cur_node.host_start = (uintptr_t) hostaddrs[i];
 948         cur_node.host_end = cur_node.host_start + sizes[i];
 949         splay_tree_key n = splay_tree_lookup (&devicep->mem_map, &cur_node);
 950         if (n)
 951           {
 952             int kind = get_kind (short_mapkind, kinds, i);
 953             if (n->host_start > cur_node.host_start
 954                 || n->host_end < cur_node.host_end)
 955               {
 956                 gomp_mutex_unlock (&devicep->lock);
 957                 gomp_fatal ("Trying to update [%p..%p) object when "
 958                             "only [%p..%p) is mapped",
 959                             (void *) cur_node.host_start,
 960                             (void *) cur_node.host_end,
 961                             (void *) n->host_start,
 962                             (void *) n->host_end);
 963               }
 964             if (GOMP_MAP_COPY_TO_P (kind & typemask))
 965               devicep->host2dev_func (devicep->target_id,
 966                                       (void *) (n->tgt->tgt_start
 967                                                 + n->tgt_offset
 968                                                 + cur_node.host_start
 969                                                 - n->host_start),
 970                                       (void *) cur_node.host_start,
 971                                       cur_node.host_end - cur_node.host_start);
 972             if (GOMP_MAP_COPY_FROM_P (kind & typemask))
 973               devicep->dev2host_func (devicep->target_id,
 974                                       (void *) cur_node.host_start,
 975                                       (void *) (n->tgt->tgt_start
 976                                                 + n->tgt_offset
 977                                                 + cur_node.host_start
 978                                                 - n->host_start),
 979                                       cur_node.host_end - cur_node.host_start);
 980           }
 981       }
 982   gomp_mutex_unlock (&devicep->lock);
 983 }
 984
 985 /* Load image pointed by TARGET_DATA to the device, specified by DEVICEP.
 986    And insert to splay tree the mapping between addresses from HOST_TABLE and
 987    from loaded target image.  We rely in the host and device compiler
 988    emitting variable and functions in the same order.  */
 989
 990 static void
 991 gomp_load_image_to_device (struct gomp_device_descr *devicep, unsigned version,
 992                            const void *host_table, const void *target_data,
 993                            bool is_register_lock)
 994 {
 995   void **host_func_table = ((void ***) host_table)[0];
 996   void **host_funcs_end  = ((void ***) host_table)[1];
 997   void **host_var_table  = ((void ***) host_table)[2];
 998   void **host_vars_end   = ((void ***) host_table)[3];
 999
1000   /* The func table contains only addresses, the var table contains addresses
1001      and corresponding sizes.  */
1002   int num_funcs = host_funcs_end - host_func_table;
1003   int num_vars  = (host_vars_end - host_var_table) / 2;
1004
1005   /* Load image to device and get target addresses for the image.  */
1006   struct addr_pair *target_table = NULL;
1007   int i, num_target_entries;
1008
1009   num_target_entries
1010     = devicep->load_image_func (devicep->target_id, version,
1011                                 target_data, &target_table);
1012
1013   if (num_target_entries != num_funcs + num_vars)
1014     {
1015       gomp_mutex_unlock (&devicep->lock);
1016       if (is_register_lock)
1017         gomp_mutex_unlock (&register_lock);
1018       gomp_fatal ("Cannot map target functions or variables"
1019                   " (expected %u, have %u)", num_funcs + num_vars,
1020                   num_target_entries);
1021     }
1022
1023   /* Insert host-target address mapping into splay tree.  */
1024   struct target_mem_desc *tgt = gomp_malloc (sizeof (*tgt));
1025   tgt->array = gomp_malloc ((num_funcs + num_vars) * sizeof (*tgt->array));
1026   tgt->refcount = REFCOUNT_INFINITY;
1027   tgt->tgt_start = 0;
1028   tgt->tgt_end = 0;
1029   tgt->to_free = NULL;
1030   tgt->prev = NULL;
1031   tgt->list_count = 0;
1032   tgt->device_descr = devicep;
1033   splay_tree_node array = tgt->array;
1034
1035   for (i = 0; i < num_funcs; i++)
1036     {
1037       splay_tree_key k = &array->key;
1038       k->host_start = (uintptr_t) host_func_table[i];
1039       k->host_end = k->host_start + 1;
1040       k->tgt = tgt;
1041       k->tgt_offset = target_table[i].start;
1042       k->refcount = REFCOUNT_INFINITY;
1043       k->async_refcount = 0;
1044       k->link_key = NULL;
1045       array->left = NULL;
1046       array->right = NULL;
1047       splay_tree_insert (&devicep->mem_map, array);
1048       array++;
1049     }
1050
1051   /* Most significant bit of the size in host and target tables marks
1052      "omp declare target link" variables.  */
1053   const uintptr_t link_bit = 1ULL << (sizeof (uintptr_t) * __CHAR_BIT__ - 1);
1054   const uintptr_t size_mask = ~link_bit;
1055
1056   for (i = 0; i < num_vars; i++)
1057     {
1058       struct addr_pair *target_var = &target_table[num_funcs + i];
1059       uintptr_t target_size = target_var->end - target_var->start;
1060
1061       if ((uintptr_t) host_var_table[i * 2 + 1] != target_size)
1062         {
1063           gomp_mutex_unlock (&devicep->lock);
1064           if (is_register_lock)
1065             gomp_mutex_unlock (&register_lock);
1066           gomp_fatal ("Cannot map target variables (size mismatch)");
1067         }
1068
1069       splay_tree_key k = &array->key;
1070       k->host_start = (uintptr_t) host_var_table[i * 2];
1071       k->host_end
1072         = k->host_start + (size_mask & (uintptr_t) host_var_table[i * 2 + 1]);
1073       k->tgt = tgt;
1074       k->tgt_offset = target_var->start;
1075       k->refcount = target_size & link_bit ? REFCOUNT_LINK : REFCOUNT_INFINITY;
1076       k->async_refcount = 0;
1077       k->link_key = NULL;
1078       array->left = NULL;
1079       array->right = NULL;
1080       splay_tree_insert (&devicep->mem_map, array);
1081       array++;
1082     }
1083
1084   free (target_table);
1085 }
1086
1087 /* Unload the mappings described by target_data from device DEVICE_P.
1088    The device must be locked.   */
1089
1090 static void
1091 gomp_unload_image_from_device (struct gomp_device_descr *devicep,
1092                                unsigned version,
1093                                const void *host_table, const void *target_data)
1094 {
1095   void **host_func_table = ((void ***) host_table)[0];
1096   void **host_funcs_end  = ((void ***) host_table)[1];
1097   void **host_var_table  = ((void ***) host_table)[2];
1098   void **host_vars_end   = ((void ***) host_table)[3];
1099
1100   /* The func table contains only addresses, the var table contains addresses
1101      and corresponding sizes.  */
1102   int num_funcs = host_funcs_end - host_func_table;
1103   int num_vars  = (host_vars_end - host_var_table) / 2;
1104
1105   struct splay_tree_key_s k;
1106   splay_tree_key node = NULL;
1107
1108   /* Find mapping at start of node array */
1109   if (num_funcs || num_vars)
1110     {
1111       k.host_start = (num_funcs ? (uintptr_t) host_func_table[0]
1112                       : (uintptr_t) host_var_table[0]);
1113       k.host_end = k.host_start + 1;
1114       node = splay_tree_lookup (&devicep->mem_map, &k);
1115     }
1116
1117   devicep->unload_image_func (devicep->target_id, version, target_data);
1118
1119   /* Remove mappings from splay tree.  */
1120   int i;
1121   for (i = 0; i < num_funcs; i++)
1122     {
1123       k.host_start = (uintptr_t) host_func_table[i];
1124       k.host_end = k.host_start + 1;
1125       splay_tree_remove (&devicep->mem_map, &k);
1126     }
1127
1128   /* Most significant bit of the size in host and target tables marks
1129      "omp declare target link" variables.  */
1130   const uintptr_t link_bit = 1ULL << (sizeof (uintptr_t) * __CHAR_BIT__ - 1);
1131   const uintptr_t size_mask = ~link_bit;
1132   bool is_tgt_unmapped = false;
1133
1134   for (i = 0; i < num_vars; i++)
1135     {
1136       k.host_start = (uintptr_t) host_var_table[i * 2];
1137       k.host_end
1138         = k.host_start + (size_mask & (uintptr_t) host_var_table[i * 2 + 1]);
1139
1140       if (!(link_bit & (uintptr_t) host_var_table[i * 2 + 1]))
1141         splay_tree_remove (&devicep->mem_map, &k);
1142       else
1143         {
1144           splay_tree_key n = splay_tree_lookup (&devicep->mem_map, &k);
1145           splay_tree_remove (&devicep->mem_map, n);
1146           if (n->link_key)
1147             {
1148               if (n->tgt->refcount > 1)
1149                 n->tgt->refcount--;
1150               else
1151                 {
1152                   is_tgt_unmapped = true;
1153                   gomp_unmap_tgt (n->tgt);
1154                 }
1155             }
1156         }
1157     }
1158
1159   if (node && !is_tgt_unmapped)
1160     {
1161       free (node->tgt);
1162       free (node);
1163     }
1164 }
1165
1166 /* This function should be called from every offload image while loading.
1167    It gets the descriptor of the host func and var tables HOST_TABLE, TYPE of
1168    the target, and TARGET_DATA needed by target plugin.  */
1169
1170 void
1171 GOMP_offload_register_ver (unsigned version, const void *host_table,
1172                            int target_type, const void *target_data)
1173 {
1174   int i;
1175
1176   if (GOMP_VERSION_LIB (version) > GOMP_VERSION)
1177     gomp_fatal ("Library too old for offload (version %u < %u)",
1178                 GOMP_VERSION, GOMP_VERSION_LIB (version));
1179
1180   gomp_mutex_lock (&register_lock);
1181
1182   /* Load image to all initialized devices.  */
1183   for (i = 0; i < num_devices; i++)
1184     {
1185       struct gomp_device_descr *devicep = &devices[i];
1186       gomp_mutex_lock (&devicep->lock);
1187       if (devicep->type == target_type
1188           && devicep->state == GOMP_DEVICE_INITIALIZED)
1189         gomp_load_image_to_device (devicep, version,
1190                                    host_table, target_data, true);
1191       gomp_mutex_unlock (&devicep->lock);
1192     }
1193
1194   /* Insert image to array of pending images.  */
1195   offload_images
1196     = gomp_realloc_unlock (offload_images,
1197                            (num_offload_images + 1)
1198                            * sizeof (struct offload_image_descr));
1199   offload_images[num_offload_images].version = version;
1200   offload_images[num_offload_images].type = target_type;
1201   offload_images[num_offload_images].host_table = host_table;
1202   offload_images[num_offload_images].target_data = target_data;
1203
1204   num_offload_images++;
1205   gomp_mutex_unlock (&register_lock);
1206 }
1207
1208 void
1209 GOMP_offload_register (const void *host_table, int target_type,
1210                        const void *target_data)
1211 {
1212   GOMP_offload_register_ver (0, host_table, target_type, target_data);
1213 }
1214
1215 /* This function should be called from every offload image while unloading.
1216    It gets the descriptor of the host func and var tables HOST_TABLE, TYPE of
1217    the target, and TARGET_DATA needed by target plugin.  */
1218
1219 void
1220 GOMP_offload_unregister_ver (unsigned version, const void *host_table,
1221                              int target_type, const void *target_data)
1222 {
1223   int i;
1224
1225   gomp_mutex_lock (&register_lock);
1226
1227   /* Unload image from all initialized devices.  */
1228   for (i = 0; i < num_devices; i++)
1229     {
1230       struct gomp_device_descr *devicep = &devices[i];
1231       gomp_mutex_lock (&devicep->lock);
1232       if (devicep->type == target_type
1233           && devicep->state == GOMP_DEVICE_INITIALIZED)
1234         gomp_unload_image_from_device (devicep, version,
1235                                        host_table, target_data);
1236       gomp_mutex_unlock (&devicep->lock);
1237     }
1238
1239   /* Remove image from array of pending images.  */
1240   for (i = 0; i < num_offload_images; i++)
1241     if (offload_images[i].target_data == target_data)
1242       {
1243         offload_images[i] = offload_images[--num_offload_images];
1244         break;
1245       }
1246
1247   gomp_mutex_unlock (&register_lock);
1248 }
1249
1250 void
1251 GOMP_offload_unregister (const void *host_table, int target_type,
1252                          const void *target_data)
1253 {
1254   GOMP_offload_unregister_ver (0, host_table, target_type, target_data);
1255 }
1256
1257 /* This function initializes the target device, specified by DEVICEP.  DEVICEP
1258    must be locked on entry, and remains locked on return.  */
1259
1260 attribute_hidden void
1261 gomp_init_device (struct gomp_device_descr *devicep)
1262 {
1263   int i;
1264   devicep->init_device_func (devicep->target_id);
1265
1266   /* Load to device all images registered by the moment.  */
1267   for (i = 0; i < num_offload_images; i++)
1268     {
1269       struct offload_image_descr *image = &offload_images[i];
1270       if (image->type == devicep->type)
1271         gomp_load_image_to_device (devicep, image->version,
1272                                    image->host_table, image->target_data,
1273                                    false);
1274     }
1275
1276   devicep->state = GOMP_DEVICE_INITIALIZED;
1277 }
1278
1279 attribute_hidden void
1280 gomp_unload_device (struct gomp_device_descr *devicep)
1281 {
1282   if (devicep->state == GOMP_DEVICE_INITIALIZED)
1283     {
1284       unsigned i;
1285
1286       /* Unload from device all images registered at the moment.  */
1287       for (i = 0; i < num_offload_images; i++)
1288         {
1289           struct offload_image_descr *image = &offload_images[i];
1290           if (image->type == devicep->type)
1291             gomp_unload_image_from_device (devicep, image->version,
1292                                            image->host_table,
1293                                            image->target_data);
1294         }
1295     }
1296 }
1297
1298 /* Free address mapping tables.  MM must be locked on entry, and remains locked
1299    on return.  */
1300
1301 attribute_hidden void
1302 gomp_free_memmap (struct splay_tree_s *mem_map)
1303 {
1304   while (mem_map->root)
1305     {
1306       struct target_mem_desc *tgt = mem_map->root->key.tgt;
1307
1308       splay_tree_remove (mem_map, &mem_map->root->key);
1309       free (tgt->array);
1310       free (tgt);
1311     }
1312 }
1313
1314 /* Host fallback for GOMP_target{,_ext} routines.  */
1315
1316 static void
1317 gomp_target_fallback (void (*fn) (void *), void **hostaddrs)
1318 {
1319   struct gomp_thread old_thr, *thr = gomp_thread ();
1320   old_thr = *thr;
1321   memset (thr, '\0', sizeof (*thr));
1322   if (gomp_places_list)
1323     {
1324       thr->place = old_thr.place;
1325       thr->ts.place_partition_len = gomp_places_list_len;
1326     }
1327   fn (hostaddrs);
1328   gomp_free_thread (thr);
1329   *thr = old_thr;
1330 }
1331
1332 /* Host fallback with firstprivate map-type handling.  */
1333
1334 static void
1335 gomp_target_fallback_firstprivate (void (*fn) (void *), size_t mapnum,
1336                                    void **hostaddrs, size_t *sizes,
1337                                    unsigned short *kinds)
1338 {
1339   size_t i, tgt_align = 0, tgt_size = 0;
1340   char *tgt = NULL;
1341   for (i = 0; i < mapnum; i++)
1342     if ((kinds[i] & 0xff) == GOMP_MAP_FIRSTPRIVATE)
1343       {
1344         size_t align = (size_t) 1 << (kinds[i] >> 8);
1345         if (tgt_align < align)
1346           tgt_align = align;
1347         tgt_size = (tgt_size + align - 1) & ~(align - 1);
1348         tgt_size += sizes[i];
1349       }
1350   if (tgt_align)
1351     {
1352       tgt = gomp_alloca (tgt_size + tgt_align - 1);
1353       uintptr_t al = (uintptr_t) tgt & (tgt_align - 1);
1354       if (al)
1355         tgt += tgt_align - al;
1356       tgt_size = 0;
1357       for (i = 0; i < mapnum; i++)
1358         if ((kinds[i] & 0xff) == GOMP_MAP_FIRSTPRIVATE)
1359           {
1360             size_t align = (size_t) 1 << (kinds[i] >> 8);
1361             tgt_size = (tgt_size + align - 1) & ~(align - 1);
1362             memcpy (tgt + tgt_size, hostaddrs[i], sizes[i]);
1363             hostaddrs[i] = tgt + tgt_size;
1364             tgt_size = tgt_size + sizes[i];
1365           }
1366     }
1367   gomp_target_fallback (fn, hostaddrs);
1368 }
1369
1370 /* Helper function of GOMP_target{,_ext} routines.  */
1371
1372 static void *
1373 gomp_get_target_fn_addr (struct gomp_device_descr *devicep,
1374                          void (*host_fn) (void *))
1375 {
1376   if (devicep->capabilities & GOMP_OFFLOAD_CAP_NATIVE_EXEC)
1377     return (void *) host_fn;
1378   else
1379     {
1380       gomp_mutex_lock (&devicep->lock);
1381       if (devicep->state == GOMP_DEVICE_FINALIZED)
1382         {
1383           gomp_mutex_unlock (&devicep->lock);
1384           return NULL;
1385         }
1386
1387       struct splay_tree_key_s k;
1388       k.host_start = (uintptr_t) host_fn;
1389       k.host_end = k.host_start + 1;
1390       splay_tree_key tgt_fn = splay_tree_lookup (&devicep->mem_map, &k);
1391       gomp_mutex_unlock (&devicep->lock);
1392       if (tgt_fn == NULL)
1393         gomp_fatal ("Target function wasn't mapped");
1394
1395       return (void *) tgt_fn->tgt_offset;
1396     }
1397 }
1398
1399 /* Called when encountering a target directive.  If DEVICE
1400    is GOMP_DEVICE_ICV, it means use device-var ICV.  If it is
1401    GOMP_DEVICE_HOST_FALLBACK (or any value
1402    larger than last available hw device), use host fallback.
1403    FN is address of host code, UNUSED is part of the current ABI, but
1404    we're not actually using it.  HOSTADDRS, SIZES and KINDS are arrays
1405    with MAPNUM entries, with addresses of the host objects,
1406    sizes of the host objects (resp. for pointer kind pointer bias
1407    and assumed sizeof (void *) size) and kinds.  */
1408
1409 void
1410 GOMP_target (int device, void (*fn) (void *), const void *unused,
1411              size_t mapnum, void **hostaddrs, size_t *sizes,
1412              unsigned char *kinds)
1413 {
1414   struct gomp_device_descr *devicep = resolve_device (device);
1415
1416   void *fn_addr;
1417   if (devicep == NULL
1418       || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400)
1419       || !(fn_addr = gomp_get_target_fn_addr (devicep, fn)))
1420     return gomp_target_fallback (fn, hostaddrs);
1421
1422   struct target_mem_desc *tgt_vars
1423     = gomp_map_vars (devicep, mapnum, hostaddrs, NULL, sizes, kinds, false,
1424                      GOMP_MAP_VARS_TARGET);
1425   devicep->run_func (devicep->target_id, fn_addr, (void *) tgt_vars->tgt_start);
1426   gomp_unmap_vars (tgt_vars, true);
1427 }
1428
1429 /* Like GOMP_target, but KINDS is 16-bit, UNUSED is no longer present,
1430    and several arguments have been added:
1431    FLAGS is a bitmask, see GOMP_TARGET_FLAG_* in gomp-constants.h.
1432    DEPEND is array of dependencies, see GOMP_task for details.
1433    NUM_TEAMS is positive if GOMP_teams will be called in the body with
1434    that value, or 1 if teams construct is not present, or 0, if
1435    teams construct does not have num_teams clause and so the choice is
1436    implementation defined, and -1 if it can't be determined on the host
1437    what value will GOMP_teams have on the device.
1438    THREAD_LIMIT similarly is positive if GOMP_teams will be called in the
1439    body with that value, or 0, if teams construct does not have thread_limit
1440    clause or the teams construct is not present, or -1 if it can't be
1441    determined on the host what value will GOMP_teams have on the device.  */
1442
1443 void
1444 GOMP_target_ext (int device, void (*fn) (void *), size_t mapnum,
1445                  void **hostaddrs, size_t *sizes, unsigned short *kinds,
1446                  unsigned int flags, void **depend, int num_teams,
1447                  int thread_limit)
1448 {
1449   struct gomp_device_descr *devicep = resolve_device (device);
1450
1451   (void) num_teams;
1452   (void) thread_limit;
1453
1454   if (flags & GOMP_TARGET_FLAG_NOWAIT)
1455     {
1456       struct gomp_thread *thr = gomp_thread ();
1457       /* Create a team if we don't have any around, as nowait
1458          target tasks make sense to run asynchronously even when
1459          outside of any parallel.  */
1460       if (__builtin_expect (thr->ts.team == NULL, 0))
1461         {
1462           struct gomp_team *team = gomp_new_team (1);
1463           struct gomp_task *task = thr->task;
1464           struct gomp_task_icv *icv = task ? &task->icv : &gomp_global_icv;
1465           team->prev_ts = thr->ts;
1466           thr->ts.team = team;
1467           thr->ts.team_id = 0;
1468           thr->ts.work_share = &team->work_shares[0];
1469           thr->ts.last_work_share = NULL;
1470 #ifdef HAVE_SYNC_BUILTINS
1471           thr->ts.single_count = 0;
1472 #endif
1473           thr->ts.static_trip = 0;
1474           thr->task = &team->implicit_task[0];
1475           gomp_init_task (thr->task, NULL, icv);
1476           if (task)
1477             {
1478               thr->task = task;
1479               gomp_end_task ();
1480               free (task);
1481               thr->task = &team->implicit_task[0];
1482             }
1483           else
1484             pthread_setspecific (gomp_thread_destructor, thr);
1485         }
1486       if (thr->ts.team
1487           && !thr->task->final_task)
1488         {
1489           gomp_create_target_task (devicep, fn, mapnum, hostaddrs,
1490                                    sizes, kinds, flags, depend,
1491                                    GOMP_TARGET_TASK_BEFORE_MAP);
1492           return;
1493         }
1494     }
1495
1496   /* If there are depend clauses, but nowait is not present
1497      (or we are in a final task), block the parent task until the
1498      dependencies are resolved and then just continue with the rest
1499      of the function as if it is a merged task.  */
1500   if (depend != NULL)
1501     {
1502       struct gomp_thread *thr = gomp_thread ();
1503       if (thr->task && thr->task->depend_hash)
1504         gomp_task_maybe_wait_for_dependencies (depend);
1505     }
1506
1507   void *fn_addr;
1508   if (devicep == NULL
1509       || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400)
1510       || !(fn_addr = gomp_get_target_fn_addr (devicep, fn)))
1511     {
1512       gomp_target_fallback_firstprivate (fn, mapnum, hostaddrs, sizes, kinds);
1513       return;
1514     }
1515
1516   struct target_mem_desc *tgt_vars
1517     = gomp_map_vars (devicep, mapnum, hostaddrs, NULL, sizes, kinds, true,
1518                      GOMP_MAP_VARS_TARGET);
1519   devicep->run_func (devicep->target_id, fn_addr, (void *) tgt_vars->tgt_start);
1520   gomp_unmap_vars (tgt_vars, true);
1521 }
1522
1523 /* Host fallback for GOMP_target_data{,_ext} routines.  */
1524
1525 static void
1526 gomp_target_data_fallback (void)
1527 {
1528   struct gomp_task_icv *icv = gomp_icv (false);
1529   if (icv->target_data)
1530     {
1531       /* Even when doing a host fallback, if there are any active
1532          #pragma omp target data constructs, need to remember the
1533          new #pragma omp target data, otherwise GOMP_target_end_data
1534          would get out of sync.  */
1535       struct target_mem_desc *tgt
1536         = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, false,
1537                          GOMP_MAP_VARS_DATA);
1538       tgt->prev = icv->target_data;
1539       icv->target_data = tgt;
1540     }
1541 }
1542
1543 void
1544 GOMP_target_data (int device, const void *unused, size_t mapnum,
1545                   void **hostaddrs, size_t *sizes, unsigned char *kinds)
1546 {
1547   struct gomp_device_descr *devicep = resolve_device (device);
1548
1549   if (devicep == NULL
1550       || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1551     return gomp_target_data_fallback ();
1552
1553   struct target_mem_desc *tgt
1554     = gomp_map_vars (devicep, mapnum, hostaddrs, NULL, sizes, kinds, false,
1555                      GOMP_MAP_VARS_DATA);
1556   struct gomp_task_icv *icv = gomp_icv (true);
1557   tgt->prev = icv->target_data;
1558   icv->target_data = tgt;
1559 }
1560
1561 void
1562 GOMP_target_data_ext (int device, size_t mapnum, void **hostaddrs,
1563                       size_t *sizes, unsigned short *kinds)
1564 {
1565   struct gomp_device_descr *devicep = resolve_device (device);
1566
1567   if (devicep == NULL
1568       || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1569     return gomp_target_data_fallback ();
1570
1571   struct target_mem_desc *tgt
1572     = gomp_map_vars (devicep, mapnum, hostaddrs, NULL, sizes, kinds, true,
1573                      GOMP_MAP_VARS_DATA);
1574   struct gomp_task_icv *icv = gomp_icv (true);
1575   tgt->prev = icv->target_data;
1576   icv->target_data = tgt;
1577 }
1578
1579 void
1580 GOMP_target_end_data (void)
1581 {
1582   struct gomp_task_icv *icv = gomp_icv (false);
1583   if (icv->target_data)
1584     {
1585       struct target_mem_desc *tgt = icv->target_data;
1586       icv->target_data = tgt->prev;
1587       gomp_unmap_vars (tgt, true);
1588     }
1589 }
1590
1591 void
1592 GOMP_target_update (int device, const void *unused, size_t mapnum,
1593                     void **hostaddrs, size_t *sizes, unsigned char *kinds)
1594 {
1595   struct gomp_device_descr *devicep = resolve_device (device);
1596
1597   if (devicep == NULL
1598       || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1599     return;
1600
1601   gomp_update (devicep, mapnum, hostaddrs, sizes, kinds, false);
1602 }
1603
1604 void
1605 GOMP_target_update_ext (int device, size_t mapnum, void **hostaddrs,
1606                         size_t *sizes, unsigned short *kinds,
1607                         unsigned int flags, void **depend)
1608 {
1609   struct gomp_device_descr *devicep = resolve_device (device);
1610
1611   /* If there are depend clauses, but nowait is not present,
1612      block the parent task until the dependencies are resolved
1613      and then just continue with the rest of the function as if it
1614      is a merged task.  Until we are able to schedule task during
1615      variable mapping or unmapping, ignore nowait if depend clauses
1616      are not present.  */
1617   if (depend != NULL)
1618     {
1619       struct gomp_thread *thr = gomp_thread ();
1620       if (thr->task && thr->task->depend_hash)
1621         {
1622           if ((flags & GOMP_TARGET_FLAG_NOWAIT)
1623               && thr->ts.team
1624               && !thr->task->final_task)
1625             {
1626               if (gomp_create_target_task (devicep, (void (*) (void *)) NULL,
1627                                            mapnum, hostaddrs, sizes, kinds,
1628                                            flags | GOMP_TARGET_FLAG_UPDATE,
1629                                            depend, GOMP_TARGET_TASK_DATA))
1630                 return;
1631             }
1632           else
1633             {
1634               struct gomp_team *team = thr->ts.team;
1635               /* If parallel or taskgroup has been cancelled, don't start new
1636                  tasks.  */
1637               if (team
1638                   && (gomp_team_barrier_cancelled (&team->barrier)
1639                       || (thr->task->taskgroup
1640                           && thr->task->taskgroup->cancelled)))
1641                 return;
1642
1643               gomp_task_maybe_wait_for_dependencies (depend);
1644             }
1645         }
1646     }
1647
1648   if (devicep == NULL
1649       || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1650     return;
1651
1652   struct gomp_thread *thr = gomp_thread ();
1653   struct gomp_team *team = thr->ts.team;
1654   /* If parallel or taskgroup has been cancelled, don't start new tasks.  */
1655   if (team
1656       && (gomp_team_barrier_cancelled (&team->barrier)
1657           || (thr->task->taskgroup && thr->task->taskgroup->cancelled)))
1658     return;
1659
1660   gomp_update (devicep, mapnum, hostaddrs, sizes, kinds, true);
1661 }
1662
1663 static void
1664 gomp_exit_data (struct gomp_device_descr *devicep, size_t mapnum,
1665                 void **hostaddrs, size_t *sizes, unsigned short *kinds)
1666 {
1667   const int typemask = 0xff;
1668   size_t i;
1669   gomp_mutex_lock (&devicep->lock);
1670   if (devicep->state == GOMP_DEVICE_FINALIZED)
1671     {
1672       gomp_mutex_unlock (&devicep->lock);
1673       return;
1674     }
1675
1676   for (i = 0; i < mapnum; i++)
1677     {
1678       struct splay_tree_key_s cur_node;
1679       unsigned char kind = kinds[i] & typemask;
1680       switch (kind)
1681         {
1682         case GOMP_MAP_FROM:
1683         case GOMP_MAP_ALWAYS_FROM:
1684         case GOMP_MAP_DELETE:
1685         case GOMP_MAP_RELEASE:
1686         case GOMP_MAP_ZERO_LEN_ARRAY_SECTION:
1687         case GOMP_MAP_DELETE_ZERO_LEN_ARRAY_SECTION:
1688           cur_node.host_start = (uintptr_t) hostaddrs[i];
1689           cur_node.host_end = cur_node.host_start + sizes[i];
1690           splay_tree_key k = (kind == GOMP_MAP_DELETE_ZERO_LEN_ARRAY_SECTION
1691                               || kind == GOMP_MAP_ZERO_LEN_ARRAY_SECTION)
1692             ? gomp_map_0len_lookup (&devicep->mem_map, &cur_node)
1693             : splay_tree_lookup (&devicep->mem_map, &cur_node);
1694           if (!k)
1695             continue;
1696
1697           if (k->refcount > 0 && k->refcount != REFCOUNT_INFINITY)
1698             k->refcount--;
1699           if ((kind == GOMP_MAP_DELETE
1700                || kind == GOMP_MAP_DELETE_ZERO_LEN_ARRAY_SECTION)
1701               && k->refcount != REFCOUNT_INFINITY)
1702             k->refcount = 0;
1703
1704           if ((kind == GOMP_MAP_FROM && k->refcount == 0)
1705               || kind == GOMP_MAP_ALWAYS_FROM)
1706             devicep->dev2host_func (devicep->target_id,
1707                                     (void *) cur_node.host_start,
1708                                     (void *) (k->tgt->tgt_start + k->tgt_offset
1709                                               + cur_node.host_start
1710                                               - k->host_start),
1711                                     cur_node.host_end - cur_node.host_start);
1712           if (k->refcount == 0)
1713             {
1714               splay_tree_remove (&devicep->mem_map, k);
1715               if (k->link_key)
1716                 splay_tree_insert (&devicep->mem_map,
1717                                    (splay_tree_node) k->link_key);
1718               if (k->tgt->refcount > 1)
1719                 k->tgt->refcount--;
1720               else
1721                 gomp_unmap_tgt (k->tgt);
1722             }
1723
1724           break;
1725         default:
1726           gomp_mutex_unlock (&devicep->lock);
1727           gomp_fatal ("GOMP_target_enter_exit_data unhandled kind 0x%.2x",
1728                       kind);
1729         }
1730     }
1731
1732   gomp_mutex_unlock (&devicep->lock);
1733 }
1734
1735 void
1736 GOMP_target_enter_exit_data (int device, size_t mapnum, void **hostaddrs,
1737                              size_t *sizes, unsigned short *kinds,
1738                              unsigned int flags, void **depend)
1739 {
1740   struct gomp_device_descr *devicep = resolve_device (device);
1741
1742   /* If there are depend clauses, but nowait is not present,
1743      block the parent task until the dependencies are resolved
1744      and then just continue with the rest of the function as if it
1745      is a merged task.  Until we are able to schedule task during
1746      variable mapping or unmapping, ignore nowait if depend clauses
1747      are not present.  */
1748   if (depend != NULL)
1749     {
1750       struct gomp_thread *thr = gomp_thread ();
1751       if (thr->task && thr->task->depend_hash)
1752         {
1753           if ((flags & GOMP_TARGET_FLAG_NOWAIT)
1754               && thr->ts.team
1755               && !thr->task->final_task)
1756             {
1757               if (gomp_create_target_task (devicep, (void (*) (void *)) NULL,
1758                                            mapnum, hostaddrs, sizes, kinds,
1759                                            flags, depend,
1760                                            GOMP_TARGET_TASK_DATA))
1761                 return;
1762             }
1763           else
1764             {
1765               struct gomp_team *team = thr->ts.team;
1766               /* If parallel or taskgroup has been cancelled, don't start new
1767                  tasks.  */
1768               if (team
1769                   && (gomp_team_barrier_cancelled (&team->barrier)
1770                       || (thr->task->taskgroup
1771                           && thr->task->taskgroup->cancelled)))
1772                 return;
1773
1774               gomp_task_maybe_wait_for_dependencies (depend);
1775             }
1776         }
1777     }
1778
1779   if (devicep == NULL
1780       || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1781     return;
1782
1783   struct gomp_thread *thr = gomp_thread ();
1784   struct gomp_team *team = thr->ts.team;
1785   /* If parallel or taskgroup has been cancelled, don't start new tasks.  */
1786   if (team
1787       && (gomp_team_barrier_cancelled (&team->barrier)
1788           || (thr->task->taskgroup && thr->task->taskgroup->cancelled)))
1789     return;
1790
1791   size_t i;
1792   if ((flags & GOMP_TARGET_FLAG_EXIT_DATA) == 0)
1793     for (i = 0; i < mapnum; i++)
1794       if ((kinds[i] & 0xff) == GOMP_MAP_STRUCT)
1795         {
1796           gomp_map_vars (devicep, sizes[i] + 1, &hostaddrs[i], NULL, &sizes[i],
1797                          &kinds[i], true, GOMP_MAP_VARS_ENTER_DATA);
1798           i += sizes[i];
1799         }
1800       else
1801         gomp_map_vars (devicep, 1, &hostaddrs[i], NULL, &sizes[i], &kinds[i],
1802                        true, GOMP_MAP_VARS_ENTER_DATA);
1803   else
1804     gomp_exit_data (devicep, mapnum, hostaddrs, sizes, kinds);
1805 }
1806
1807 bool
1808 gomp_target_task_fn (void *data)
1809 {
1810   struct gomp_target_task *ttask = (struct gomp_target_task *) data;
1811   struct gomp_device_descr *devicep = ttask->devicep;
1812
1813   if (ttask->fn != NULL)
1814     {
1815       void *fn_addr;
1816       if (devicep == NULL
1817           || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400)
1818           || !(fn_addr = gomp_get_target_fn_addr (devicep, ttask->fn)))
1819         {
1820           ttask->state = GOMP_TARGET_TASK_FALLBACK;
1821           gomp_target_fallback_firstprivate (ttask->fn, ttask->mapnum,
1822                                              ttask->hostaddrs, ttask->sizes,
1823                                              ttask->kinds);
1824           return false;
1825         }
1826
1827       if (ttask->state == GOMP_TARGET_TASK_FINISHED)
1828         {
1829           gomp_unmap_vars (ttask->tgt, true);
1830           return false;
1831         }
1832
1833       ttask->tgt
1834         = gomp_map_vars (devicep, ttask->mapnum, ttask->hostaddrs, NULL,
1835                          ttask->sizes, ttask->kinds, true,
1836                          GOMP_MAP_VARS_TARGET);
1837       ttask->state = GOMP_TARGET_TASK_READY_TO_RUN;
1838
1839       devicep->async_run_func (devicep->target_id, fn_addr,
1840                                (void *) ttask->tgt->tgt_start, (void *) ttask);
1841       return true;
1842     }
1843   else if (devicep == NULL
1844            || !(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1845     return false;
1846
1847   size_t i;
1848   if (ttask->flags & GOMP_TARGET_FLAG_UPDATE)
1849     gomp_update (devicep, ttask->mapnum, ttask->hostaddrs, ttask->sizes,
1850                  ttask->kinds, true);
1851   else if ((ttask->flags & GOMP_TARGET_FLAG_EXIT_DATA) == 0)
1852     for (i = 0; i < ttask->mapnum; i++)
1853       if ((ttask->kinds[i] & 0xff) == GOMP_MAP_STRUCT)
1854         {
1855           gomp_map_vars (devicep, ttask->sizes[i] + 1, &ttask->hostaddrs[i],
1856                          NULL, &ttask->sizes[i], &ttask->kinds[i], true,
1857                          GOMP_MAP_VARS_ENTER_DATA);
1858           i += ttask->sizes[i];
1859         }
1860       else
1861         gomp_map_vars (devicep, 1, &ttask->hostaddrs[i], NULL, &ttask->sizes[i],
1862                        &ttask->kinds[i], true, GOMP_MAP_VARS_ENTER_DATA);
1863   else
1864     gomp_exit_data (devicep, ttask->mapnum, ttask->hostaddrs, ttask->sizes,
1865                     ttask->kinds);
1866   return false;
1867 }
1868
1869 void
1870 GOMP_teams (unsigned int num_teams, unsigned int thread_limit)
1871 {
1872   if (thread_limit)
1873     {
1874       struct gomp_task_icv *icv = gomp_icv (true);
1875       icv->thread_limit_var
1876         = thread_limit > INT_MAX ? UINT_MAX : thread_limit;
1877     }
1878   (void) num_teams;
1879 }
1880
1881 void *
1882 omp_target_alloc (size_t size, int device_num)
1883 {
1884   if (device_num == GOMP_DEVICE_HOST_FALLBACK)
1885     return malloc (size);
1886
1887   if (device_num < 0)
1888     return NULL;
1889
1890   struct gomp_device_descr *devicep = resolve_device (device_num);
1891   if (devicep == NULL)
1892     return NULL;
1893
1894   if (!(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1895     return malloc (size);
1896
1897   gomp_mutex_lock (&devicep->lock);
1898   void *ret = devicep->alloc_func (devicep->target_id, size);
1899   gomp_mutex_unlock (&devicep->lock);
1900   return ret;
1901 }
1902
1903 void
1904 omp_target_free (void *device_ptr, int device_num)
1905 {
1906   if (device_ptr == NULL)
1907     return;
1908
1909   if (device_num == GOMP_DEVICE_HOST_FALLBACK)
1910     {
1911       free (device_ptr);
1912       return;
1913     }
1914
1915   if (device_num < 0)
1916     return;
1917
1918   struct gomp_device_descr *devicep = resolve_device (device_num);
1919   if (devicep == NULL)
1920     return;
1921
1922   if (!(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1923     {
1924       free (device_ptr);
1925       return;
1926     }
1927
1928   gomp_mutex_lock (&devicep->lock);
1929   devicep->free_func (devicep->target_id, device_ptr);
1930   gomp_mutex_unlock (&devicep->lock);
1931 }
1932
1933 int
1934 omp_target_is_present (void *ptr, int device_num)
1935 {
1936   if (ptr == NULL)
1937     return 1;
1938
1939   if (device_num == GOMP_DEVICE_HOST_FALLBACK)
1940     return 1;
1941
1942   if (device_num < 0)
1943     return 0;
1944
1945   struct gomp_device_descr *devicep = resolve_device (device_num);
1946   if (devicep == NULL)
1947     return 0;
1948
1949   if (!(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1950     return 1;
1951
1952   gomp_mutex_lock (&devicep->lock);
1953   struct splay_tree_s *mem_map = &devicep->mem_map;
1954   struct splay_tree_key_s cur_node;
1955
1956   cur_node.host_start = (uintptr_t) ptr;
1957   cur_node.host_end = cur_node.host_start;
1958   splay_tree_key n = gomp_map_0len_lookup (mem_map, &cur_node);
1959   int ret = n != NULL;
1960   gomp_mutex_unlock (&devicep->lock);
1961   return ret;
1962 }
1963
1964 int
1965 omp_target_memcpy (void *dst, void *src, size_t length, size_t dst_offset,
1966                    size_t src_offset, int dst_device_num, int src_device_num)
1967 {
1968   struct gomp_device_descr *dst_devicep = NULL, *src_devicep = NULL;
1969
1970   if (dst_device_num != GOMP_DEVICE_HOST_FALLBACK)
1971     {
1972       if (dst_device_num < 0)
1973         return EINVAL;
1974
1975       dst_devicep = resolve_device (dst_device_num);
1976       if (dst_devicep == NULL)
1977         return EINVAL;
1978
1979       if (!(dst_devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1980         dst_devicep = NULL;
1981     }
1982   if (src_device_num != GOMP_DEVICE_HOST_FALLBACK)
1983     {
1984       if (src_device_num < 0)
1985         return EINVAL;
1986
1987       src_devicep = resolve_device (src_device_num);
1988       if (src_devicep == NULL)
1989         return EINVAL;
1990
1991       if (!(src_devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
1992         src_devicep = NULL;
1993     }
1994   if (src_devicep == NULL && dst_devicep == NULL)
1995     {
1996       memcpy ((char *) dst + dst_offset, (char *) src + src_offset, length);
1997       return 0;
1998     }
1999   if (src_devicep == NULL)
2000     {
2001       gomp_mutex_lock (&dst_devicep->lock);
2002       dst_devicep->host2dev_func (dst_devicep->target_id,
2003                                   (char *) dst + dst_offset,
2004                                   (char *) src + src_offset, length);
2005       gomp_mutex_unlock (&dst_devicep->lock);
2006       return 0;
2007     }
2008   if (dst_devicep == NULL)
2009     {
2010       gomp_mutex_lock (&src_devicep->lock);
2011       src_devicep->dev2host_func (src_devicep->target_id,
2012                                   (char *) dst + dst_offset,
2013                                   (char *) src + src_offset, length);
2014       gomp_mutex_unlock (&src_devicep->lock);
2015       return 0;
2016     }
2017   if (src_devicep == dst_devicep)
2018     {
2019       gomp_mutex_lock (&src_devicep->lock);
2020       src_devicep->dev2dev_func (src_devicep->target_id,
2021                                  (char *) dst + dst_offset,
2022                                  (char *) src + src_offset, length);
2023       gomp_mutex_unlock (&src_devicep->lock);
2024       return 0;
2025     }
2026   return EINVAL;
2027 }
2028
2029 static int
2030 omp_target_memcpy_rect_worker (void *dst, void *src, size_t element_size,
2031                                int num_dims, const size_t *volume,
2032                                const size_t *dst_offsets,
2033                                const size_t *src_offsets,
2034                                const size_t *dst_dimensions,
2035                                const size_t *src_dimensions,
2036                                struct gomp_device_descr *dst_devicep,
2037                                struct gomp_device_descr *src_devicep)
2038 {
2039   size_t dst_slice = element_size;
2040   size_t src_slice = element_size;
2041   size_t j, dst_off, src_off, length;
2042   int i, ret;
2043
2044   if (num_dims == 1)
2045     {
2046       if (__builtin_mul_overflow (element_size, volume[0], &length)
2047           || __builtin_mul_overflow (element_size, dst_offsets[0], &dst_off)
2048           || __builtin_mul_overflow (element_size, src_offsets[0], &src_off))
2049         return EINVAL;
2050       if (dst_devicep == NULL && src_devicep == NULL)
2051         memcpy ((char *) dst + dst_off, (char *) src + src_off, length);
2052       else if (src_devicep == NULL)
2053         dst_devicep->host2dev_func (dst_devicep->target_id,
2054                                     (char *) dst + dst_off,
2055                                     (char *) src + src_off, length);
2056       else if (dst_devicep == NULL)
2057         src_devicep->dev2host_func (src_devicep->target_id,
2058                                     (char *) dst + dst_off,
2059                                     (char *) src + src_off, length);
2060       else if (src_devicep == dst_devicep)
2061         src_devicep->dev2dev_func (src_devicep->target_id,
2062                                    (char *) dst + dst_off,
2063                                    (char *) src + src_off, length);
2064       else
2065         return EINVAL;
2066       return 0;
2067     }
2068
2069   /* FIXME: it would be nice to have some plugin function to handle
2070      num_dims == 2 and num_dims == 3 more efficiently.  Larger ones can
2071      be handled in the generic recursion below, and for host-host it
2072      should be used even for any num_dims >= 2.  */
2073
2074   for (i = 1; i < num_dims; i++)
2075     if (__builtin_mul_overflow (dst_slice, dst_dimensions[i], &dst_slice)
2076         || __builtin_mul_overflow (src_slice, src_dimensions[i], &src_slice))
2077       return EINVAL;
2078   if (__builtin_mul_overflow (dst_slice, dst_offsets[0], &dst_off)
2079       || __builtin_mul_overflow (src_slice, src_offsets[0], &src_off))
2080     return EINVAL;
2081   for (j = 0; j < volume[0]; j++)
2082     {
2083       ret = omp_target_memcpy_rect_worker ((char *) dst + dst_off,
2084                                            (char *) src + src_off,
2085                                            element_size, num_dims - 1,
2086                                            volume + 1, dst_offsets + 1,
2087                                            src_offsets + 1, dst_dimensions + 1,
2088                                            src_dimensions + 1, dst_devicep,
2089                                            src_devicep);
2090       if (ret)
2091         return ret;
2092       dst_off += dst_slice;
2093       src_off += src_slice;
2094     }
2095   return 0;
2096 }
2097
2098 int
2099 omp_target_memcpy_rect (void *dst, void *src, size_t element_size,
2100                         int num_dims, const size_t *volume,
2101                         const size_t *dst_offsets,
2102                         const size_t *src_offsets,
2103                         const size_t *dst_dimensions,
2104                         const size_t *src_dimensions,
2105                         int dst_device_num, int src_device_num)
2106 {
2107   struct gomp_device_descr *dst_devicep = NULL, *src_devicep = NULL;
2108
2109   if (!dst && !src)
2110     return INT_MAX;
2111
2112   if (dst_device_num != GOMP_DEVICE_HOST_FALLBACK)
2113     {
2114       if (dst_device_num < 0)
2115         return EINVAL;
2116
2117       dst_devicep = resolve_device (dst_device_num);
2118       if (dst_devicep == NULL)
2119         return EINVAL;
2120
2121       if (!(dst_devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
2122         dst_devicep = NULL;
2123     }
2124   if (src_device_num != GOMP_DEVICE_HOST_FALLBACK)
2125     {
2126       if (src_device_num < 0)
2127         return EINVAL;
2128
2129       src_devicep = resolve_device (src_device_num);
2130       if (src_devicep == NULL)
2131         return EINVAL;
2132
2133       if (!(src_devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
2134         src_devicep = NULL;
2135     }
2136
2137   if (src_devicep != NULL && dst_devicep != NULL && src_devicep != dst_devicep)
2138     return EINVAL;
2139
2140   if (src_devicep)
2141     gomp_mutex_lock (&src_devicep->lock);
2142   else if (dst_devicep)
2143     gomp_mutex_lock (&dst_devicep->lock);
2144   int ret = omp_target_memcpy_rect_worker (dst, src, element_size, num_dims,
2145                                            volume, dst_offsets, src_offsets,
2146                                            dst_dimensions, src_dimensions,
2147                                            dst_devicep, src_devicep);
2148   if (src_devicep)
2149     gomp_mutex_unlock (&src_devicep->lock);
2150   else if (dst_devicep)
2151     gomp_mutex_unlock (&dst_devicep->lock);
2152   return ret;
2153 }
2154
2155 int
2156 omp_target_associate_ptr (void *host_ptr, void *device_ptr, size_t size,
2157                           size_t device_offset, int device_num)
2158 {
2159   if (device_num == GOMP_DEVICE_HOST_FALLBACK)
2160     return EINVAL;
2161
2162   if (device_num < 0)
2163     return EINVAL;
2164
2165   struct gomp_device_descr *devicep = resolve_device (device_num);
2166   if (devicep == NULL)
2167     return EINVAL;
2168
2169   if (!(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
2170     return EINVAL;
2171
2172   gomp_mutex_lock (&devicep->lock);
2173
2174   struct splay_tree_s *mem_map = &devicep->mem_map;
2175   struct splay_tree_key_s cur_node;
2176   int ret = EINVAL;
2177
2178   cur_node.host_start = (uintptr_t) host_ptr;
2179   cur_node.host_end = cur_node.host_start + size;
2180   splay_tree_key n = gomp_map_lookup (mem_map, &cur_node);
2181   if (n)
2182     {
2183       if (n->tgt->tgt_start + n->tgt_offset
2184           == (uintptr_t) device_ptr + device_offset
2185           && n->host_start <= cur_node.host_start
2186           && n->host_end >= cur_node.host_end)
2187         ret = 0;
2188     }
2189   else
2190     {
2191       struct target_mem_desc *tgt = gomp_malloc (sizeof (*tgt));
2192       tgt->array = gomp_malloc (sizeof (*tgt->array));
2193       tgt->refcount = 1;
2194       tgt->tgt_start = 0;
2195       tgt->tgt_end = 0;
2196       tgt->to_free = NULL;
2197       tgt->prev = NULL;
2198       tgt->list_count = 0;
2199       tgt->device_descr = devicep;
2200       splay_tree_node array = tgt->array;
2201       splay_tree_key k = &array->key;
2202       k->host_start = cur_node.host_start;
2203       k->host_end = cur_node.host_end;
2204       k->tgt = tgt;
2205       k->tgt_offset = (uintptr_t) device_ptr + device_offset;
2206       k->refcount = REFCOUNT_INFINITY;
2207       k->async_refcount = 0;
2208       array->left = NULL;
2209       array->right = NULL;
2210       splay_tree_insert (&devicep->mem_map, array);
2211       ret = 0;
2212     }
2213   gomp_mutex_unlock (&devicep->lock);
2214   return ret;
2215 }
2216
2217 int
2218 omp_target_disassociate_ptr (void *ptr, int device_num)
2219 {
2220   if (device_num == GOMP_DEVICE_HOST_FALLBACK)
2221     return EINVAL;
2222
2223   if (device_num < 0)
2224     return EINVAL;
2225
2226   struct gomp_device_descr *devicep = resolve_device (device_num);
2227   if (devicep == NULL)
2228     return EINVAL;
2229
2230   if (!(devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
2231     return EINVAL;
2232
2233   gomp_mutex_lock (&devicep->lock);
2234
2235   struct splay_tree_s *mem_map = &devicep->mem_map;
2236   struct splay_tree_key_s cur_node;
2237   int ret = EINVAL;
2238
2239   cur_node.host_start = (uintptr_t) ptr;
2240   cur_node.host_end = cur_node.host_start;
2241   splay_tree_key n = gomp_map_lookup (mem_map, &cur_node);
2242   if (n
2243       && n->host_start == cur_node.host_start
2244       && n->refcount == REFCOUNT_INFINITY
2245       && n->tgt->tgt_start == 0
2246       && n->tgt->to_free == NULL
2247       && n->tgt->refcount == 1
2248       && n->tgt->list_count == 0)
2249     {
2250       splay_tree_remove (&devicep->mem_map, n);
2251       gomp_unmap_tgt (n->tgt);
2252       ret = 0;
2253     }
2254
2255   gomp_mutex_unlock (&devicep->lock);
2256   return ret;
2257 }
2258
2259 #ifdef PLUGIN_SUPPORT
2260
2261 /* This function tries to load a plugin for DEVICE.  Name of plugin is passed
2262    in PLUGIN_NAME.
2263    The handles of the found functions are stored in the corresponding fields
2264    of DEVICE.  The function returns TRUE on success and FALSE otherwise.  */
2265
2266 static bool
2267 gomp_load_plugin_for_device (struct gomp_device_descr *device,
2268                              const char *plugin_name)
2269 {
2270   const char *err = NULL, *last_missing = NULL;
2271
2272   void *plugin_handle = dlopen (plugin_name, RTLD_LAZY);
2273   if (!plugin_handle)
2274     goto dl_fail;
2275
2276   /* Check if all required functions are available in the plugin and store
2277      their handlers.  None of the symbols can legitimately be NULL,
2278      so we don't need to check dlerror all the time.  */
2279 #define DLSYM(f)                                                        \
2280   if (!(device->f##_func = dlsym (plugin_handle, "GOMP_OFFLOAD_" #f)))  \
2281     goto dl_fail
2282   /* Similar, but missing functions are not an error.  Return false if
2283      failed, true otherwise.  */
2284 #define DLSYM_OPT(f, n)                                                 \
2285   ((device->f##_func = dlsym (plugin_handle, "GOMP_OFFLOAD_" #n))       \
2286    || (last_missing = #n, 0))
2287
2288   DLSYM (version);
2289   if (device->version_func () != GOMP_VERSION)
2290     {
2291       err = "plugin version mismatch";
2292       goto fail;
2293     }
2294
2295   DLSYM (get_name);
2296   DLSYM (get_caps);
2297   DLSYM (get_type);
2298   DLSYM (get_num_devices);
2299   DLSYM (init_device);
2300   DLSYM (fini_device);
2301   DLSYM (load_image);
2302   DLSYM (unload_image);
2303   DLSYM (alloc);
2304   DLSYM (free);
2305   DLSYM (dev2host);
2306   DLSYM (host2dev);
2307   device->capabilities = device->get_caps_func ();
2308   if (device->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400)
2309     {
2310       DLSYM (run);
2311       DLSYM (async_run);
2312       DLSYM (dev2dev);
2313     }
2314   if (device->capabilities & GOMP_OFFLOAD_CAP_OPENACC_200)
2315     {
2316       if (!DLSYM_OPT (openacc.exec, openacc_parallel)
2317           || !DLSYM_OPT (openacc.register_async_cleanup,
2318                          openacc_register_async_cleanup)
2319           || !DLSYM_OPT (openacc.async_test, openacc_async_test)
2320           || !DLSYM_OPT (openacc.async_test_all, openacc_async_test_all)
2321           || !DLSYM_OPT (openacc.async_wait, openacc_async_wait)
2322           || !DLSYM_OPT (openacc.async_wait_async, openacc_async_wait_async)
2323           || !DLSYM_OPT (openacc.async_wait_all, openacc_async_wait_all)
2324           || !DLSYM_OPT (openacc.async_wait_all_async,
2325                          openacc_async_wait_all_async)
2326           || !DLSYM_OPT (openacc.async_set_async, openacc_async_set_async)
2327           || !DLSYM_OPT (openacc.create_thread_data,
2328                          openacc_create_thread_data)
2329           || !DLSYM_OPT (openacc.destroy_thread_data,
2330                          openacc_destroy_thread_data))
2331         {
2332           /* Require all the OpenACC handlers if we have
2333              GOMP_OFFLOAD_CAP_OPENACC_200.  */
2334           err = "plugin missing OpenACC handler function";
2335           goto fail;
2336         }
2337
2338       unsigned cuda = 0;
2339       cuda += DLSYM_OPT (openacc.cuda.get_current_device,
2340                          openacc_get_current_cuda_device);
2341       cuda += DLSYM_OPT (openacc.cuda.get_current_context,
2342                          openacc_get_current_cuda_context);
2343       cuda += DLSYM_OPT (openacc.cuda.get_stream, openacc_get_cuda_stream);
2344       cuda += DLSYM_OPT (openacc.cuda.set_stream, openacc_set_cuda_stream);
2345       if (cuda && cuda != 4)
2346         {
2347           /* Make sure all the CUDA functions are there if any of them are.  */
2348           err = "plugin missing OpenACC CUDA handler function";
2349           goto fail;
2350         }
2351     }
2352 #undef DLSYM
2353 #undef DLSYM_OPT
2354
2355   return 1;
2356
2357  dl_fail:
2358   err = dlerror ();
2359  fail:
2360   gomp_error ("while loading %s: %s", plugin_name, err);
2361   if (last_missing)
2362     gomp_error ("missing function was %s", last_missing);
2363   if (plugin_handle)
2364     dlclose (plugin_handle);
2365
2366   return 0;
2367 }
2368
2369 /* This function finalizes all initialized devices.  */
2370
2371 static void
2372 gomp_target_fini (void)
2373 {
2374   int i;
2375   for (i = 0; i < num_devices; i++)
2376     {
2377       struct gomp_device_descr *devicep = &devices[i];
2378       gomp_mutex_lock (&devicep->lock);
2379       if (devicep->state == GOMP_DEVICE_INITIALIZED)
2380         {
2381           devicep->fini_device_func (devicep->target_id);
2382           devicep->state = GOMP_DEVICE_FINALIZED;
2383         }
2384       gomp_mutex_unlock (&devicep->lock);
2385     }
2386 }
2387
2388 /* This function initializes the runtime needed for offloading.
2389    It parses the list of offload targets and tries to load the plugins for
2390    these targets.  On return, the variables NUM_DEVICES and NUM_DEVICES_OPENMP
2391    will be set, and the array DEVICES initialized, containing descriptors for
2392    corresponding devices, first the GOMP_OFFLOAD_CAP_OPENMP_400 ones, follows
2393    by the others.  */
2394
2395 static void
2396 gomp_target_init (void)
2397 {
2398   const char *prefix ="libgomp-plugin-";
2399   const char *suffix = SONAME_SUFFIX (1);
2400   const char *cur, *next;
2401   char *plugin_name;
2402   int i, new_num_devices;
2403
2404   num_devices = 0;
2405   devices = NULL;
2406
2407   cur = OFFLOAD_TARGETS;
2408   if (*cur)
2409     do
2410       {
2411         struct gomp_device_descr current_device;
2412
2413         next = strchr (cur, ',');
2414
2415         plugin_name = (char *) malloc (1 + (next ? next - cur : strlen (cur))
2416                                        + strlen (prefix) + strlen (suffix));
2417         if (!plugin_name)
2418           {
2419             num_devices = 0;
2420             break;
2421           }
2422
2423         strcpy (plugin_name, prefix);
2424         strncat (plugin_name, cur, next ? next - cur : strlen (cur));
2425         strcat (plugin_name, suffix);
2426
2427         if (gomp_load_plugin_for_device (&current_device, plugin_name))
2428           {
2429             new_num_devices = current_device.get_num_devices_func ();
2430             if (new_num_devices >= 1)
2431               {
2432                 /* Augment DEVICES and NUM_DEVICES.  */
2433
2434                 devices = realloc (devices, (num_devices + new_num_devices)
2435                                    * sizeof (struct gomp_device_descr));
2436                 if (!devices)
2437                   {
2438                     num_devices = 0;
2439                     free (plugin_name);
2440                     break;
2441                   }
2442
2443                 current_device.name = current_device.get_name_func ();
2444                 /* current_device.capabilities has already been set.  */
2445                 current_device.type = current_device.get_type_func ();
2446                 current_device.mem_map.root = NULL;
2447                 current_device.state = GOMP_DEVICE_UNINITIALIZED;
2448                 current_device.openacc.data_environ = NULL;
2449                 for (i = 0; i < new_num_devices; i++)
2450                   {
2451                     current_device.target_id = i;
2452                     devices[num_devices] = current_device;
2453                     gomp_mutex_init (&devices[num_devices].lock);
2454                     num_devices++;
2455                   }
2456               }
2457           }
2458
2459         free (plugin_name);
2460         cur = next + 1;
2461       }
2462     while (next);
2463
2464   /* In DEVICES, sort the GOMP_OFFLOAD_CAP_OPENMP_400 ones first, and set
2465      NUM_DEVICES_OPENMP.  */
2466   struct gomp_device_descr *devices_s
2467     = malloc (num_devices * sizeof (struct gomp_device_descr));
2468   if (!devices_s)
2469     {
2470       num_devices = 0;
2471       free (devices);
2472       devices = NULL;
2473     }
2474   num_devices_openmp = 0;
2475   for (i = 0; i < num_devices; i++)
2476     if (devices[i].capabilities & GOMP_OFFLOAD_CAP_OPENMP_400)
2477       devices_s[num_devices_openmp++] = devices[i];
2478   int num_devices_after_openmp = num_devices_openmp;
2479   for (i = 0; i < num_devices; i++)
2480     if (!(devices[i].capabilities & GOMP_OFFLOAD_CAP_OPENMP_400))
2481       devices_s[num_devices_after_openmp++] = devices[i];
2482   free (devices);
2483   devices = devices_s;
2484
2485   for (i = 0; i < num_devices; i++)
2486     {
2487       /* The 'devices' array can be moved (by the realloc call) until we have
2488          found all the plugins, so registering with the OpenACC runtime (which
2489          takes a copy of the pointer argument) must be delayed until now.  */
2490       if (devices[i].capabilities & GOMP_OFFLOAD_CAP_OPENACC_200)
2491         goacc_register (&devices[i]);
2492     }
2493
2494   if (atexit (gomp_target_fini) != 0)
2495     gomp_fatal ("atexit failed");
2496 }
2497
2498 #else /* PLUGIN_SUPPORT */
2499 /* If dlfcn.h is unavailable we always fallback to host execution.
2500    GOMP_target* routines are just stubs for this case.  */
2501 static void
2502 gomp_target_init (void)
2503 {
2504 }
2505 #endif /* PLUGIN_SUPPORT */