/*
 * omp-debug.cpp
 *
 *  Created on: Jan 14, 2015
 *      Author: Ignacio Laguna
 *              Joachim Protze
 *     Contact: ilaguna@llnl.gov
 *              protze@llnl.gov
 */
/*******************************************************************************
 * This implements an OMPD DLL for the LLVM OpenMP runtime library.
 */

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#define NDEBUG 1

#include "omp-debug.h"
#include "TargetValue.h"
#include "omp.h"
#include "ompd-private.h"
#include <assert.h>
#include <cstdio>
#include <inttypes.h>
#include <pthread.h>
#include <stdint.h>

ompd_device_type_sizes_t type_sizes;
uint64_t ompd_state;
ompd_rc_t ompd_get_num_threads(
    ompd_parallel_handle_t *parallel_handle, /* IN: OpenMP parallel handle */
    ompd_word_t *val /* OUT: number of threads */);

/* --- OMPD functions ------------------------------------------------------- */

/* --- Initialization ------------------------------------------------------- */

ompd_rc_t ompd_initialize(ompd_word_t version, const ompd_callbacks_t *table) {
  ompd_rc_t ret = ompd_rc_ok;
  ompd_word_t ompd_version;

  if (!table)
    return ompd_rc_bad_input;

  ompd_get_api_version(&ompd_version);
  if (version != ompd_version)
    return ompd_rc_unsupported;
  callbacks = table;
  TValue::callbacks = table;
  __ompd_init_icvs(table);
  __ompd_init_states(table);

  return ret;
}

ompd_rc_t ompd_finalize(void) { return ompd_rc_ok; }

ompd_rc_t ompd_process_initialize(
    ompd_address_space_context_t
        *context, /* IN: debugger handle for the target */
    ompd_address_space_handle_t **handle /* OUT: ompd handle for the target */
) {
  if (!context)
    return ompd_rc_bad_input;
  if (!handle)
    return ompd_rc_bad_input;

  ompd_rc_t ret = initTypeSizes(context);
  if (ret != ompd_rc_ok)
    return ret;

  ret = TValue(context, "ompd_state")
            .castBase(ompd_type_long_long)
            .getValue(ompd_state);
  if (ret != ompd_rc_ok)
    return ret;
  ret = callbacks->alloc_memory(sizeof(ompd_address_space_handle_t),
                                (void **)(handle));
  if (ret != ompd_rc_ok)
    return ret;
  if (!*handle)
    return ompd_rc_error;

  (*handle)->context = context;
  (*handle)->kind = OMPD_DEVICE_KIND_HOST;

  return ompd_rc_ok;
}

ompd_rc_t
ompd_get_omp_version(ompd_address_space_handle_t
                         *address_space, /* IN: handle for the address space */
                     ompd_word_t *version) {
  if (!address_space)
    return ompd_rc_stale_handle;
  if (!version)
    return ompd_rc_bad_input;

  ompd_address_space_context_t *context = address_space->context;
  ompd_rc_t ret;

  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ret = TValue(context, "__kmp_openmp_version")
            .castBase(ompd_type_int)
            .getValue(*version);
  return ret;
}

ompd_rc_t ompd_get_omp_version_string(
    ompd_address_space_handle_t
        *address_space, /* IN: handle for the address space */
    const char **string) {
  if (!address_space)
    return ompd_rc_stale_handle;
  if (!string)
    return ompd_rc_bad_input;
  ompd_address_space_context_t *context = address_space->context;
  ompd_word_t ver;
  ompd_rc_t ret;
  char *omp_version;
  ret = callbacks->alloc_memory(10, /* max digit can be store on int*/
                                (void **)&omp_version);

  if (ret != ompd_rc_ok)
    return ret;

  ret = TValue(context, "__kmp_openmp_version")
            .castBase(ompd_type_int)
            .getValue(ver);
  if (ret != ompd_rc_ok)
    return ret;

  sprintf(omp_version, "%ld", ver);
  *string = omp_version;
  return ret;
}

ompd_rc_t ompd_rel_address_space_handle(
    ompd_address_space_handle_t
        *addr_handle /* IN: handle for the address space */
) {
  if (!addr_handle)
    return ompd_rc_stale_handle;

  ompd_rc_t ret = callbacks->free_memory((void *)(addr_handle));
  //  delete addr_handle;
  return ret;
}

ompd_rc_t ompd_device_initialize(ompd_address_space_handle_t *process_handle,
                                 ompd_address_space_context_t *device_context,
                                 ompd_device_t kind, ompd_size_t sizeof_id,
                                 void *id,
                                 ompd_address_space_handle_t **device_handle) {
  if (!device_context)
    return ompd_rc_bad_input;

  return ompd_rc_unavailable;
}

/* --- Thread Handles ------------------------------------------------------- */

/* thread_handle is of type (kmp_base_info_t) */

ompd_rc_t ompd_get_thread_in_parallel(
    ompd_parallel_handle_t *parallel_handle, /* IN: OpenMP parallel handle */
    int thread_num, /* IN: Thread num, handle of which is to be returned */
    ompd_thread_handle_t **thread_handle /* OUT: handle */
) {
  if (!parallel_handle)
    return ompd_rc_stale_handle;
  if (!parallel_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = parallel_handle->ah->context;
  ompd_rc_t ret;

  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_word_t team_size_var;
  ret = ompd_get_num_threads(parallel_handle, &team_size_var);
  if (ret != ompd_rc_ok)
    return ret;
  if (thread_num < 0 || thread_num >= team_size_var)
    return ompd_rc_bad_input;

  ompd_address_t taddr = {OMPD_SEGMENT_UNSPECIFIED, 0};

  ret = TValue(context, parallel_handle->th) /* t */
            .cast("kmp_base_team_t", 0)
            .access("t_threads") /*t.t_threads*/
            .cast("kmp_info_t", 2)
            .getArrayElement(thread_num) /*t.t_threads[nth_handle]*/
            .access("th")                /*t.t_threads[i]->th*/
            .getAddress(&taddr);

  if (ret != ompd_rc_ok)
    return ret;

  ret = callbacks->alloc_memory(sizeof(ompd_thread_handle_t),
                                (void **)(thread_handle));
  if (ret != ompd_rc_ok)
    return ret;

  (*thread_handle)->th = taddr;
  (*thread_handle)->ah = parallel_handle->ah;
  return ret;
}

ompd_rc_t ompd_rel_thread_handle(
    ompd_thread_handle_t
        *thread_handle /* IN: OpenMP thread handle to be released */
) {
  if (!thread_handle)
    return ompd_rc_stale_handle;
  ompd_rc_t ret = callbacks->free_memory((void *)(thread_handle));
  if (ret != ompd_rc_ok)
    return ret;
  return ompd_rc_ok;
}

ompd_rc_t ompd_thread_handle_compare(ompd_thread_handle_t *thread_handle_1,
                                     ompd_thread_handle_t *thread_handle_2,
                                     int *cmp_value) {
  if (!thread_handle_1)
    return ompd_rc_stale_handle;
  if (!thread_handle_2)
    return ompd_rc_stale_handle;
  if (!cmp_value)
    return ompd_rc_bad_input;
  if (thread_handle_1->ah->kind != thread_handle_2->ah->kind)
    return ompd_rc_bad_input;
  *cmp_value = thread_handle_1->th.address - thread_handle_2->th.address;

  return ompd_rc_ok;
}

/* --- Parallel Region Handles----------------------------------------------- */

/* parallel_handle is of type (kmp_base_team_t)*/

ompd_rc_t ompd_get_curr_parallel_handle(
    ompd_thread_handle_t *thread_handle,     /* IN: OpenMP thread handle*/
    ompd_parallel_handle_t **parallel_handle /* OUT: OpenMP parallel handle */
) {
  if (!thread_handle)
    return ompd_rc_stale_handle;
  if (!thread_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = thread_handle->ah->context;
  ompd_thread_context_t *thread_context = thread_handle->thread_context;
  if (!context || !thread_context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_rc_t ret;

  ompd_address_t taddr = {OMPD_SEGMENT_UNSPECIFIED, 0},
                 lwt = {OMPD_SEGMENT_UNSPECIFIED, 0};

  TValue teamdata = TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
                        .cast("kmp_base_info_t")
                        .access("th_team") /*__kmp_threads[t]->th.th_team*/
                        .cast("kmp_team_p", 1)
                        .access("t"); /*__kmp_threads[t]->th.th_team->t*/

  ret = teamdata.getAddress(&taddr);
  if (ret != ompd_rc_ok)
    return ret;

  lwt.segment = OMPD_SEGMENT_UNSPECIFIED;
  ret = teamdata.cast("kmp_base_team_t", 0)
            .access("ompt_serialized_team_info")
            .castBase()
            .getValue(lwt.address);
  if (ret != ompd_rc_ok)
    return ret;

  ret = callbacks->alloc_memory(sizeof(ompd_parallel_handle_t),
                                (void **)(parallel_handle));
  if (ret != ompd_rc_ok)
    return ret;

  (*parallel_handle)->ah = thread_handle->ah;
  (*parallel_handle)->th = taddr;
  (*parallel_handle)->lwt = lwt;
  return ompd_rc_ok;
}

ompd_rc_t ompd_get_enclosing_parallel_handle(
    ompd_parallel_handle_t *parallel_handle, /* IN: OpenMP parallel handle */
    ompd_parallel_handle_t *
        *enclosing_parallel_handle /* OUT: OpenMP parallel handle */
) {
  if (!parallel_handle)
    return ompd_rc_stale_handle;
  if (!parallel_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = parallel_handle->ah->context;

  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_address_t taddr = parallel_handle->th,
                 lwt = {OMPD_SEGMENT_UNSPECIFIED, 0};
  ompd_rc_t ret;

  ret = ompd_rc_stale_handle;
  TValue lwtValue = TValue(context, parallel_handle->lwt);
  if (lwtValue.getError() == ompd_rc_ok) // lwt == 0x0
  {                                      // if we are in lwt, get parent
    ret = lwtValue.cast("ompt_lw_taskteam_t", 0)
              .access("parent")
              .cast("ompt_lw_taskteam_t", 1)
              .dereference()
              .getAddress(&lwt);
  }
  if (ret != ompd_rc_ok) { // no lwt or parent==0x0

    TValue teamdata =
        TValue(context, parallel_handle->th) /*__kmp_threads[t]->th*/
            .cast("kmp_base_team_t", 0)      /*t*/
            .access("t_parent")              /*t.t_parent*/
            .cast("kmp_team_p", 1)
            .access("t"); /*t.t_parent->t*/

    ret = teamdata.getAddress(&taddr);
    if (ret != ompd_rc_ok)
      return ret;

    lwt.segment = OMPD_SEGMENT_UNSPECIFIED;
    ret = teamdata.cast("kmp_base_team_t", 0)
              .access("ompt_serialized_team_info")
              .castBase()
              .getValue(lwt.address);
    if (ret != ompd_rc_ok)
      return ret;
  }

  ret = callbacks->alloc_memory(sizeof(ompd_parallel_handle_t),
                                (void **)(enclosing_parallel_handle));
  if (ret != ompd_rc_ok)
    return ret;
  (*enclosing_parallel_handle)->th = taddr;
  (*enclosing_parallel_handle)->lwt = lwt;
  (*enclosing_parallel_handle)->ah = parallel_handle->ah;
  return ompd_rc_ok;
}

ompd_rc_t ompd_get_task_parallel_handle(
    ompd_task_handle_t *task_handle, /* IN: OpenMP task handle */
    ompd_parallel_handle_t *
        *task_parallel_handle /* OUT: OpenMP parallel handle */
) {
  if (!task_handle)
    return ompd_rc_stale_handle;
  if (!task_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = task_handle->ah->context;

  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_address_t taddr = {OMPD_SEGMENT_UNSPECIFIED, 0};

  ompd_rc_t ret;

  ret = TValue(context, task_handle->th)
            .cast("kmp_taskdata_t") /*td*/
            .access("td_team")      /*td.td_team*/
            .cast("kmp_team_p", 1)
            .access("t") /*td.td_team->t*/
            .getAddress(&taddr);

  if (ret != ompd_rc_ok)
    return ret;

  ret = callbacks->alloc_memory(sizeof(ompd_parallel_handle_t),
                                (void **)(task_parallel_handle));
  if (ret != ompd_rc_ok)
    return ret;

  (*task_parallel_handle)->ah = task_handle->ah;
  (*task_parallel_handle)->lwt = task_handle->lwt;
  (*task_parallel_handle)->th = taddr;
  return ompd_rc_ok;
}

ompd_rc_t ompd_rel_parallel_handle(
    ompd_parallel_handle_t *parallel_handle /* IN: OpenMP parallel handle */
) {
  if (!parallel_handle)
    return ompd_rc_stale_handle;
  ompd_rc_t ret = callbacks->free_memory((void *)(parallel_handle));
  if (ret != ompd_rc_ok)
    return ret;
  return ompd_rc_ok;
}

ompd_rc_t
ompd_parallel_handle_compare(ompd_parallel_handle_t *parallel_handle_1,
                             ompd_parallel_handle_t *parallel_handle_2,
                             int *cmp_value) {
  if (!parallel_handle_1)
    return ompd_rc_stale_handle;
  if (!parallel_handle_2)
    return ompd_rc_stale_handle;
  if (!cmp_value)
    return ompd_rc_bad_input;
  if (parallel_handle_1->ah->kind != parallel_handle_2->ah->kind)
    return ompd_rc_bad_input;
  if (parallel_handle_1->ah->kind == OMPD_DEVICE_KIND_HOST) {
    if (parallel_handle_1->th.address - parallel_handle_2->th.address)
      *cmp_value =
          parallel_handle_1->th.address - parallel_handle_2->th.address;
    else
      *cmp_value =
          parallel_handle_1->lwt.address - parallel_handle_2->lwt.address;
  } else {
    *cmp_value = parallel_handle_1->th.address - parallel_handle_2->th.address;
  }
  return ompd_rc_ok;
}

/* ------- Task Handles ----------------------------------------------------- */

/* task_handle is of type (kmp_taskdata_t) */

ompd_rc_t ompd_get_curr_task_handle(
    ompd_thread_handle_t *thread_handle, /* IN: OpenMP thread handle*/
    ompd_task_handle_t **task_handle     /* OUT: OpenMP task handle */
) {
  if (!thread_handle)
    return ompd_rc_stale_handle;
  if (!thread_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = thread_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_address_t taddr = {OMPD_SEGMENT_UNSPECIFIED, 0},
                 lwt = {OMPD_SEGMENT_UNSPECIFIED, 0};
  ompd_rc_t ret = ompd_rc_ok;

  lwt.segment = OMPD_SEGMENT_UNSPECIFIED;

  TValue taskdata =
      TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
          .cast("kmp_base_info_t")
          .access("th_current_task") /*__kmp_threads[t]->th.th_current_task*/
          .cast("kmp_taskdata_t", 1);

  ret = taskdata.dereference().getAddress(&taddr);
  if (ret != ompd_rc_ok)
    return ret;

  ret = taskdata
            .access("td_team") /*td.td_team*/
            .cast("kmp_team_p", 1)
            .access("t") /*td.td_team->t*/
            .cast("kmp_base_team_t", 0)
            .access("ompt_serialized_team_info")
            .castBase()
            .getValue(lwt.address);

  if (ret != ompd_rc_ok)
    return ret;

  ret = callbacks->alloc_memory(sizeof(ompd_task_handle_t),
                                (void **)(task_handle));
  if (ret != ompd_rc_ok)
    return ret;

  (*task_handle)->th = taddr;
  (*task_handle)->lwt = lwt;
  (*task_handle)->ah = thread_handle->ah;
  return ompd_rc_ok;
}

ompd_rc_t ompd_get_generating_task_handle(
    ompd_task_handle_t *task_handle,        /* IN: OpenMP task handle */
    ompd_task_handle_t **parent_task_handle /* OUT: OpenMP task handle */
) {
  if (!task_handle)
    return ompd_rc_stale_handle;
  if (!task_handle->ah)
    return ompd_rc_stale_handle;

  ompd_address_space_context_t *context = task_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;
  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_address_t taddr = task_handle->th, lwt = {OMPD_SEGMENT_UNSPECIFIED, 0};

  ompd_rc_t ret = ompd_rc_stale_handle;
  TValue lwtValue = TValue(context, task_handle->lwt);
  if (lwtValue.getError() == ompd_rc_ok) // lwt == 0x0
  {                                      // if we are in lwt, get parent
    ret = lwtValue.cast("ompt_lw_taskteam_t", 0)
              .access("parent")
              .cast("ompt_lw_taskteam_t", 1)
              .dereference()
              .getAddress(&lwt);
  }
  if (ret != ompd_rc_ok) { // no lwt or parent==0x0

    TValue taskdata = TValue(context, task_handle->th) /*__kmp_threads[t]->th*/
                          .cast("kmp_taskdata_t")      /*td*/
                          .access("td_parent")         /*td->td_parent*/
                          .cast("kmp_taskdata_t", 1);

    ret = taskdata.dereference().getAddress(&taddr);
    if (ret != ompd_rc_ok)
      return ret;

    lwt.segment = OMPD_SEGMENT_UNSPECIFIED;
    ret = taskdata
              .access("td_team") /*td.td_team*/
              .cast("kmp_team_p", 1)
              .access("t") /*td.td_team->t*/
              .cast("kmp_base_team_t", 0)
              .access("ompt_serialized_team_info")
              .castBase()
              .getValue(lwt.address);
    if (ret != ompd_rc_ok)
      return ret;
  }

  ret = callbacks->alloc_memory(sizeof(ompd_task_handle_t),
                                (void **)(parent_task_handle));
  if (ret != ompd_rc_ok)
    return ret;

  (*parent_task_handle)->th = taddr;
  (*parent_task_handle)->lwt = lwt;
  (*parent_task_handle)->ah = task_handle->ah;
  return ret;
}

ompd_rc_t ompd_get_scheduling_task_handle(
    ompd_task_handle_t *task_handle,        /* IN: OpenMP task handle */
    ompd_task_handle_t **parent_task_handle /* OUT: OpenMP task handle */
) {
  if (!task_handle)
    return ompd_rc_stale_handle;
  if (!task_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = task_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_address_t taddr = {OMPD_SEGMENT_UNSPECIFIED, 0};
  ompd_rc_t ret;

  ret = TValue(context, task_handle->th)
            .cast("kmp_taskdata_t")   /*td*/
            .access("ompt_task_info") // td->ompt_task_info
            .cast("ompt_task_info_t")
            .access("scheduling_parent") // td->ompd_task_info.scheduling_parent
            .cast("kmp_taskdata_t", 1)
            .castBase()
            .getValue(taddr.address);
  if (taddr.address == 0) {
    return ompd_rc_unavailable;
  }

  if (ret != ompd_rc_ok)
    return ret;
  ret = callbacks->alloc_memory(sizeof(ompd_task_handle_t),
                                (void **)(parent_task_handle));
  if (ret != ompd_rc_ok)
    return ret;

  (*parent_task_handle)->th = taddr;
  (*parent_task_handle)->lwt = {OMPD_SEGMENT_UNSPECIFIED, 0};
  (*parent_task_handle)->ah = task_handle->ah;
  return ret;
}

ompd_rc_t ompd_get_task_in_parallel(
    ompd_parallel_handle_t *parallel_handle, /* IN: OpenMP parallel handle */
    int thread_num, /* IN: thread num of implicit task of team */
    ompd_task_handle_t **task_handle /* OUT: OpenMP task handle */
) {
  if (!parallel_handle)
    return ompd_rc_stale_handle;
  if (!parallel_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = parallel_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_rc_t ret;
  ompd_word_t team_size_var;
  ret = ompd_get_num_threads(parallel_handle, &team_size_var);
  if (ret != ompd_rc_ok)
    return ret;
  if (thread_num < 0 || thread_num >= team_size_var)
    return ompd_rc_bad_input;

  ompd_address_t taddr = {OMPD_SEGMENT_UNSPECIFIED, 0};

  ret = TValue(context, parallel_handle->th) /* t */
            .cast("kmp_base_team_t", 0)
            .access("t_implicit_task_taskdata") /*t.t_implicit_task_taskdata*/
            .cast("kmp_taskdata_t", 1)
            .getArrayElement(
                thread_num) /*t.t_implicit_task_taskdata[nth_handle]*/
            .getAddress(&taddr);

  if (ret != ompd_rc_ok)
    return ret;
  ret = callbacks->alloc_memory(sizeof(ompd_task_handle_t),
                                (void **)(task_handle));
  if (ret != ompd_rc_ok)
    return ret;

  (*task_handle)->th = taddr;
  (*task_handle)->ah = parallel_handle->ah;
  (*task_handle)->lwt = {OMPD_SEGMENT_UNSPECIFIED, 0};
  return ret;
}

ompd_rc_t ompd_rel_task_handle(
    ompd_task_handle_t *task_handle /* IN: OpenMP task handle */
) {
  if (!task_handle)
    return ompd_rc_stale_handle;
  ompd_rc_t ret = callbacks->free_memory((void *)(task_handle));
  if (ret != ompd_rc_ok)
    return ret;
  return ompd_rc_ok;
}

ompd_rc_t ompd_task_handle_compare(ompd_task_handle_t *task_handle_1,
                                   ompd_task_handle_t *task_handle_2,
                                   int *cmp_value) {
  if (!task_handle_1)
    return ompd_rc_stale_handle;
  if (!task_handle_2)
    return ompd_rc_stale_handle;
  if (!cmp_value)
    return ompd_rc_bad_input;
  if (task_handle_1->ah->kind != task_handle_2->ah->kind)
    return ompd_rc_bad_input;
  if (task_handle_1->th.address - task_handle_2->th.address)
    *cmp_value = task_handle_1->th.address - task_handle_2->th.address;
  else
    *cmp_value = task_handle_1->lwt.address - task_handle_2->lwt.address;
  return ompd_rc_ok;
}

ompd_rc_t ompd_get_thread_handle(
    ompd_address_space_handle_t *handle, /* IN: handle for the address space */
    ompd_thread_id_t kind, ompd_size_t sizeof_thread_id, const void *thread_id,
    ompd_thread_handle_t **thread_handle) {
  if (!handle)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = handle->context;
  ompd_rc_t ret;

  if (!context)
    return ompd_rc_stale_handle;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }
  ompd_thread_context_t *tcontext;
  ret = callbacks->get_thread_context_for_thread_id(
      context, kind, sizeof_thread_id, thread_id, &tcontext);
  if (ret != ompd_rc_ok)
    return ret;

  int tId;

  ret = TValue(context, tcontext, "__kmp_gtid")
            .castBase("__kmp_gtid")
            .getValue(tId);
  if (ret != ompd_rc_ok)
    return ret;

  if (tId < 0) // thread is no omp worker
    return ompd_rc_unavailable;

  TValue th = TValue(context, "__kmp_threads") // __kmp_threads
                  .cast("kmp_info_t", 2)
                  .getArrayElement(tId) /*__kmp_threads[t]*/
                  .access("th");        /*__kmp_threads[t]->th*/

  ompd_address_t taddr = {OMPD_SEGMENT_UNSPECIFIED, 0};
  ret = th.getAddress(&taddr);
  if (ret != ompd_rc_ok)
    return ret;
  ret = callbacks->alloc_memory(sizeof(ompd_thread_handle_t),
                                (void **)(thread_handle));
  if (ret != ompd_rc_ok)
    return ret;
  (*thread_handle)->ah = handle;
  (*thread_handle)->th = taddr;

#ifndef NDEBUG
  if (ret != ompd_rc_ok)
    return ret;

  pthread_t oshandle;
  TBaseValue ds_handle =
      th.cast("kmp_base_info_t")
          .access("th_info") /*__kmp_threads[t]->th.th_info*/
          .cast("kmp_desc_t")
          .access("ds") /*__kmp_threads[t]->th.th_info.ds*/
          .cast("kmp_desc_base_t")
          .access("ds_thread") /*__kmp_threads[t]->th.th_info.ds.ds_thread*/
          .castBase();

  assert(ompd_rc_ok == ds_handle.getValue(oshandle) &&
         oshandle == *(pthread_t *)(thread_id) &&
         "Callback table not initialized!");
#endif

  (*thread_handle)->thread_context = tcontext;
  return ret;
}

ompd_rc_t ompd_get_thread_id(
    ompd_thread_handle_t *thread_handle, /* IN: OpenMP thread handle*/
    ompd_thread_id_t kind, ompd_size_t sizeof_thread_id, void *thread_id) {
  if (kind != OMPD_THREAD_ID_PTHREAD)
    return ompd_rc_unsupported;
  if (!thread_id)
    return ompd_rc_bad_input;
  if (!thread_handle)
    return ompd_rc_stale_handle;
  if (!thread_handle->ah)
    return ompd_rc_stale_handle;
  ompd_address_space_context_t *context = thread_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;
  ompd_rc_t ret;

  ompd_size_t size;
  ret = tf.getType(context, "kmp_thread_t").getSize(&size);
  if (ret != ompd_rc_ok)
    return ret;
  if (sizeof_thread_id != size)
    return ompd_rc_bad_input;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ret = TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
            .cast("kmp_base_info_t")
            .access("th_info") /*__kmp_threads[t]->th.th_info*/
            .cast("kmp_desc_t")
            .access("ds") /*__kmp_threads[t]->th.th_info.ds*/
            .cast("kmp_desc_base_t")
            .access("ds_thread") /*__kmp_threads[t]->th.th_info.ds.ds_thread*/
            .cast("kmp_thread_t")
            .getRawValue(thread_id, 1);

  return ret;
}

/* --- OMPT Thread State Inquiry Analogue ----------------------------------- */

ompd_rc_t ompd_get_state(
    ompd_thread_handle_t *thread_handle, /* IN: OpenMP thread handle*/
    ompd_word_t *state,                  /* OUT: State of this thread */
    ompd_wait_id_t *wait_id              /* OUT: Wait ID */
) {
  if (!thread_handle)
    return ompd_rc_stale_handle;
  if (!thread_handle->ah)
    return ompd_rc_stale_handle;
  if (!state)
    return ompd_rc_bad_input;
  ompd_address_space_context_t *context = thread_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;
  if (!ompd_state)
    return ompd_rc_needs_state_tracking;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }
  ompd_rc_t ret;

  TValue ompt_thread_info =
      TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
          .cast("kmp_base_info_t")
          .access("ompt_thread_info") /*__kmp_threads[t]->th.ompt_thread_info*/
          .cast("ompt_thread_info_t");
  if (ompt_thread_info.gotError())
    return ompt_thread_info.getError();
  ret = ompt_thread_info
            .access("state") /*__kmp_threads[t]->th.ompt_thread_info.state*/
            .castBase()
            .getValue(*state);
  if (ret != ompd_rc_ok)
    return ret;
  if (wait_id)
    ret = ompt_thread_info
              .access("wait_id") /*__kmp_threads[t]->th.ompt_thread_info.state*/
              .castBase()
              .getValue(*wait_id);

  return ret;
}

/* ---  Task Inquiry -------------------------------------------------------- */

/* ---  Task Settings ------------------------------------------------------- */

/* ---  OMPT Task Inquiry Analogues ----------------------------------------- */

ompd_rc_t
ompd_get_task_frame(ompd_task_handle_t *task_handle, /* IN: OpenMP task handle*/
                    ompd_frame_info_t *exit_frame,
                    ompd_frame_info_t *enter_frame) {
  if (!task_handle)
    return ompd_rc_stale_handle;
  if (!task_handle->ah)
    return ompd_rc_stale_handle;
  if (!exit_frame || !enter_frame)
    return ompd_rc_bad_input;
  ompd_address_space_context_t *context = task_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;
  if (!ompd_state)
    return ompd_rc_needs_state_tracking;

  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_rc_t ret;

  TValue taskInfo;
  if (task_handle->lwt.address != 0)
    taskInfo =
        TValue(context, task_handle->lwt).cast("ompt_lw_taskteam_t", 0); /*lwt*/
  else
    taskInfo = TValue(context, task_handle->th).cast("kmp_taskdata_t", 0); /*t*/
  TValue frame = taskInfo
                     .access("ompt_task_info") // td->ompt_task_info
                     .cast("ompt_task_info_t")
                     .access("frame") // td->ompd_task_info.frame
                     .cast("ompt_frame_t", 0);
  enter_frame->frame_address.segment = OMPD_SEGMENT_UNSPECIFIED;
  ret = frame
            .access("enter_frame") // td->ompt_task_info.frame.enter_frame
            .castBase()
            .getValue(enter_frame->frame_address.address);

  if (ret != ompd_rc_ok)
    return ret;

  exit_frame->frame_address.segment = OMPD_SEGMENT_UNSPECIFIED;
  ret = frame
            .access("exit_frame") // td->ompt_task_info.frame.exit_frame
            .castBase()
            .getValue(exit_frame->frame_address.address);

  return ret;
}

ompd_rc_t ompd_get_task_function(
    ompd_task_handle_t *task_handle, /* IN: OpenMP task handle */
    ompd_address_t *task_addr /* OUT: first instruction in the task region */
) {
  if (!task_handle)
    return ompd_rc_stale_handle;
  if (!task_handle->ah)
    return ompd_rc_stale_handle;
  if (!task_addr)
    return ompd_rc_bad_input;
  ompd_address_space_context_t *context = task_handle->ah->context;
  if (!context)
    return ompd_rc_stale_handle;
  if (!ompd_state)
    return ompd_rc_needs_state_tracking;
  if (!callbacks) {
    return ompd_rc_callback_error;
  }

  ompd_rc_t ret;

  task_addr->segment = OMPD_SEGMENT_UNSPECIFIED;
  TValue taskInfo;
  if (task_handle->lwt.address != 0)
    return ompd_rc_bad_input; // We need to decide what we do here.
  else {
    ompd_word_t val;
    ret = TValue(context, task_handle->th)
              .cast("kmp_taskdata_t") // td
              .access("td_flags")     // td->td_flags
              .cast("kmp_tasking_flags_t")
              .check("tasktype", &val); // td->td_flags.tasktype

    if (ret != ompd_rc_ok)
      return ret;

    if (val == 1) { // tasktype: explicit = 1, implicit = 0

      ret = TValue(context, task_handle->th)
                .cast("kmp_taskdata_t", 0) /*t*/
                .getArrayElement(
                    1) /* see kmp.h: #define KMP_TASKDATA_TO_TASK(taskdata)
                          (kmp_task_t *)(taskdata + 1) */
                .cast("kmp_task_t", 0) /* (kmp_task_t *) */
                .access("routine")     /*td->ompt_task_info*/
                .castBase()
                .getValue(task_addr->address);

    } else {

      ret = TValue(context, task_handle->th)
                .cast("kmp_taskdata_t") /*td*/
                .access("td_team")      /*td.td_team*/
                .cast("kmp_team_p", 1)
                .access("t") /*td.td_team->t*/
                .cast("kmp_base_team_t", 0)
                .access("t_pkfn") /*td.td_team->t.t_pkfn*/
                .castBase()
                .getValue(task_addr->address);
    }
  }

  return ret;
}

/* ------- OMPD Version and Compatibility Information ----------------------- */

ompd_rc_t ompd_get_api_version(ompd_word_t *version) {
  if (!version)
    return ompd_rc_bad_input;

  *version = OMPD_VERSION;
  return ompd_rc_ok;
}

ompd_rc_t
ompd_get_version_string(const char **string /* OUT: OMPD version string */
) {
  if (!string)
    return ompd_rc_bad_input;

  static const char version_string[] =
      "LLVM OpenMP " STR(OMPD_IMPLEMENTS_OPENMP) "." STR(
          OMPD_IMPLEMENTS_OPENMP_SUBVERSION) " Debugging Library implmenting "
                                             "TR " STR(OMPD_TR_VERSION) "" STR(
                                                 OMPD_TR_SUBVERSION);
  *string = version_string;
  return ompd_rc_ok;
}

/* ------ Display Control Variables ----------------------------------------- */

ompd_rc_t ompd_get_display_control_vars(ompd_address_space_handle_t *handle,
                                        const char *const **control_vars) {
  if (!handle)
    return ompd_rc_stale_handle;
  if (!control_vars)
    return ompd_rc_bad_input;

  ompd_address_space_context_t *context = handle->context;
  if (!context)
    return ompd_rc_stale_handle;

  // runtime keeps a full dump of OMP/KMP definitions in this format
  // <var1 name>=<var1 value>\n<var2 name>=<var2 value>\n...
  ompd_address_t block_addr = {ompd_segment_none, 0};
  OMPD_GET_VALUE(context, NULL, "ompd_env_block", type_sizes.sizeof_pointer,
                 &block_addr.address);

  // query size of the block
  ompd_size_t block_size;
  OMPD_GET_VALUE(context, NULL, "ompd_env_block_size", sizeof(ompd_size_t),
                 &block_size);

  // copy raw data from the address space
  char *block;
  OMPD_CALLBACK(alloc_memory, block_size, (void **)&block);
  OMPD_CALLBACK(read_memory, context, NULL, &block_addr, block_size, block);

  // count number of items, replace new line to zero.
  int block_items = 1; // also count the last "NULL" item
  for (ompd_size_t i = 0; i < block_size; i++) {
    if (block[i] == '\n') {
      block_items++;
      block[i] = '\0';
    }
  }

  // create vector of char*
  const char **ctl_vars;
  OMPD_CALLBACK(alloc_memory, block_items * sizeof(char *),
                (void **)(&ctl_vars));
  char *pos = block;
  ctl_vars[0] = block;

  // ctl_vars[0] points to the entire block, ctl_vars[1]... points to the
  // smaller subsets of the block, and ctl_vars[block_items-2] points to the
  // last string in the block.
  for (int i = 1; i < block_items - 1; i++) {
    while (*pos++ != '\0')
      ;
    if (pos > block + block_size)
      return ompd_rc_error;
    ctl_vars[i] = pos;
  }
  // last item must be NULL
  ctl_vars[block_items - 1] = NULL;

  *control_vars = ctl_vars;

  return ompd_rc_ok;
}

ompd_rc_t ompd_rel_display_control_vars(const char *const **control_vars) {
  if (!control_vars)
    return ompd_rc_bad_input;

  char **ctl_vars = const_cast<char **>(*control_vars);

  // remove the raw block first
  OMPD_CALLBACK(free_memory, (void *)ctl_vars[0]);
  // remove the vector
  OMPD_CALLBACK(free_memory, (void *)ctl_vars);

  return ompd_rc_ok;
}

/* --- Helper functions ----------------------------------------------------- */

ompd_rc_t initTypeSizes(ompd_address_space_context_t *context) {
  static int inited = 0;
  static ompd_rc_t ret;
  if (inited)
    return ret;
  ret = callbacks->sizeof_type(context, &type_sizes);
  if (ret != ompd_rc_ok)
    return ret;
  if (!(type_sizes.sizeof_pointer > 0))
    return ompd_rc_error;
  ret = callbacks->sizeof_type(context, &TValue::type_sizes);
  if (ret != ompd_rc_ok)
    return ret;
  inited = 1;
  return ret;
}