llvm/cxa_finalize/cxa_finalize.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
 */

/* A Solaris implementation of the Itanium C++ ABI __cxa_atexit
 * and __cxa_finalize functions.
 */

#include <stdlib.h>
#include <pthread.h>

#include "cxa_finalize.h"

#define __CXA_FUNC_CALLBACK 0
#define __CXA_FUNC_DONE     1
#define __CXA_ATEXIT_CHUNK  64

#define __DSO_TYPE_DESTRUCTOR 1
#define __DSO_TYPE_DLCLOSE    2

#define __DSO_SCOPE_LOCAL  4
#define __DSO_SCOPE_GLOBAL 8

#ifdef __cplusplus
extern "C" {
#endif

typedef struct __cxxabi_atexit {
  void (*cxa_func)(void*);
  uint32_t type;
  uint32_t dso_type;
  uint32_t dso_scope;
  void* arg;
  void* dso;
} cxxabi_atexit;

typedef struct __cxxabi_atexit_list {
  uint32_t size;
  uint32_t nelem;
  cxxabi_atexit* list;
} cxxabi_atexit_list;

__attribute__((__visibility__("hidden")))
extern void* __dso_handle;

static cxxabi_atexit_list _list;
static pthread_mutex_t _mtx = PTHREAD_MUTEX_INITIALIZER;
static uint32_t _registered = 0;
static uint32_t _initialized = 0;

static int __register_with_atexit(const cxxabi_atexit* cxa);
static int __init_cxxabi_list(cxxabi_atexit** list);
static int __resize_cxxabi_list(const cxxabi_atexit* oldlist, uint32_t nelem,
                                cxxabi_atexit** newlist, uint32_t newsize);
void __cxa_atexit_callback(void);
static void __attribute__((destructor)) __do_cleanup(void);

int __init_cxxabi_list(cxxabi_atexit** list) {
  cxxabi_atexit* __p =
    (cxxabi_atexit *) malloc (__CXA_ATEXIT_CHUNK * sizeof(cxxabi_atexit));

  if (__p == NULL)
    return -1;

  *list = __p;
  return 0;
}

int __resize_cxxabi_list(const cxxabi_atexit* oldlist, uint32_t nelem,
                         cxxabi_atexit** newlist, uint32_t newsize) {
  register cxxabi_atexit* __p =
    (cxxabi_atexit *) malloc (newsize * sizeof(cxxabi_atexit));

  if (__p == NULL)
    return -1;

  const cxxabi_atexit* __l = oldlist;

  for (uint32_t i = 0; i < nelem; ++i)
    *(__p + i) = *(__l + i);

  *newlist = __p;

  return 0;
}

int __register_with_atexit(const cxxabi_atexit* cxa) {
  int ret = 0;

  if (cxa == NULL)
    return -1;

  pthread_mutex_lock(&_mtx);

  if (_initialized == 0) {
    _list.nelem = 0;

    ret = __init_cxxabi_list(&_list.list);

    if (ret == -1) {
      pthread_mutex_unlock(&_mtx);
      return ret;
    }

    _list.size = __CXA_ATEXIT_CHUNK;
    _initialized = 1;
  }

  if (_list.nelem == _list.size) {
    uint32_t newsize = _list.size * 2;
    cxxabi_atexit* __p;

    ret = __resize_cxxabi_list(_list.list, _list.nelem, &__p, newsize);

    if (ret == -1) {
      free (_list.list);
      _list.list = NULL;
      _list.size = 0;
      _list.nelem = 0;
      pthread_mutex_unlock(&_mtx);
      return ret;
    }

    _list.list = __p;
    _list.size = newsize;
  }

  if (_registered == 0) {
    ret = atexit(__cxa_atexit_callback);
    _registered = (ret == 0);
  }

  if (_registered != 1) {
    free (_list.list);
    _list.list = NULL;
    _list.size = 0;
    _list.nelem = 0;
    pthread_mutex_unlock(&_mtx);
    return ret;
  }

  register cxxabi_atexit* __p = _list.list + _list.nelem;
  *__p = *cxa;
  ++_list.nelem;

  pthread_mutex_unlock(&_mtx);
  return ret;
}

void __cxa_atexit_callback(void) {
  cxxabi_atexit* __e = _list.list + (_list.nelem - 1);
  cxxabi_atexit* __p = __e;

  if (__p == NULL)
    return;

  /* destroy local scope objects first */
  for (int i = _list.nelem; i > 0; --i) {
    if ((__p->type == __CXA_FUNC_CALLBACK) &&
        (__p->dso_scope == __DSO_SCOPE_LOCAL)) {
      __p->type = __CXA_FUNC_DONE;
      __p->cxa_func(__p->arg);
    }
    --__p;
  }

  __p = __e;

  /* destroy global scope objects last */
  for (int i = _list.nelem; i > 0; --i) {
    if ((__p->type == __CXA_FUNC_CALLBACK) &&
        (__p->dso_scope == __DSO_SCOPE_GLOBAL)) {
      __p->type = __CXA_FUNC_DONE;
      __p->cxa_func(__p->arg);
    }
    --__p;
  }
}

int __cxa_atexit(void (*destructor)(void*), void* arg, void* dso) {
  cxxabi_atexit cxa;

  cxa.type = __CXA_FUNC_CALLBACK;

  /* get dso_type from dso object itself */
  cxa.dso_type = __DSO_TYPE_DESTRUCTOR;

  /* get dso scope from dso object */
  cxa.dso_scope = __DSO_SCOPE_GLOBAL;
  cxa.cxa_func = destructor;
  cxa.arg = arg;
  cxa.dso = dso;

  return __register_with_atexit(&cxa);
}

int __cxa_finalize(void* dso) {
  uint32_t i;
  pthread_mutex_lock(&_mtx);

  if (_initialized == 0) {
    pthread_mutex_unlock(&_mtx);
    return -1;
  }

  cxxabi_atexit* __p = _list.list;
  pthread_mutex_unlock(&_mtx);

  if (__p == NULL)
    return -1;

  if (dso == NULL) {
    __p = _list.list + (_list.nelem - 1);

    pthread_mutex_lock(&_mtx);

    for (i = _list.nelem; i > 0; --i) {
      if (__p->type == __CXA_FUNC_DONE) {
        --__p;
        continue;
      }

      uint32_t __type = __p->type;
      __p->type = __CXA_FUNC_DONE;
      pthread_mutex_unlock(&_mtx);

      if (__type == __CXA_FUNC_CALLBACK)
        __p->cxa_func(__p->arg);

      --__p;
      pthread_mutex_lock(&_mtx);
    }

    pthread_mutex_unlock(&_mtx);
  } else {
    i = 0;
    do {
      if (__p->dso == dso) {
        pthread_mutex_lock(&_mtx);
        uint32_t __type = __p->type;
        __p->type = __CXA_FUNC_DONE;
        pthread_mutex_unlock(&_mtx);

        if (__type == __CXA_FUNC_CALLBACK)
          __p->cxa_func(__p->arg);
      }
      ++__p; ++i;
    } while (i < _list.nelem);
  }

  return 0;
}

void __attribute__((destructor)) __do_cleanup(void) {
  __cxa_finalize(__dso_handle);
}

#ifdef __cplusplus
}
#endif