/usr/include/python3.9/object.h

Bug Summary

File:	usr/include/python3.9/object.h
Warning:	line 128, column 12 Access to field 'ob_type' results in a dereference of a null pointer (loaded from variable 'ob')

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ompdModule.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=../../../../ -fdebug-prefix-map=/build/source/= -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-19/lib/clang/19 -I projects/openmp/libompd/gdb-plugin -I /build/source/openmp/libompd/gdb-plugin -I include -I /build/source/llvm/include -I /build/source/openmp/libompd/src -I projects/openmp/runtime/src -I /build/source/openmp/runtime/src -I /usr/include/python3.9 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D ompdModule_EXPORTS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=../../../../ -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=../../../../ -fcoverage-prefix-map=/build/source/= -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -Wno-extra -Wno-pedantic -Wno-maybe-uninitialized -fconst-strings -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-04-02-020108-72015-1 -x c /build/source/openmp/libompd/gdb-plugin/ompdModule.c

/build/source/openmp/libompd/gdb-plugin/ompdModule.c

→

1/*
* ompdModule.c
*/

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

13#include <Python.h>
14#include <omp-tools.h>
15// #include <ompd.h>
16#include <dlfcn.h>
17#include <errno(*__errno_location ()).h>
18#include <pthread.h>
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>

23void *ompd_library;

25#define OMPD_WEAK_ATTR__attribute__((weak)) __attribute__((weak))

27struct _ompd_aspace_cont {
int id;
29};
30struct _ompd_thread_cont {
int id;
32};
33ompd_address_space_context_t acontext = {42};

35PyObject *pModule;

37ompd_rc_t _print(const char *str, int category);

39// NOTE: implement functions to check parameters of OMPD API functions for
40// correctness
41OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_api_version(ompd_word_t *addr) {
static ompd_rc_t (*my_get_api_version)(ompd_word_t *) = NULL((void*)0);
if (!my_get_api_version) {
  my_get_api_version = dlsym(ompd_library, "ompd_get_api_version");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_api_version(addr);
50}

52OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_version_string(const char **string) {
static ompd_rc_t (*my_get_version_string)(const char **) = NULL((void*)0);
if (!my_get_version_string) {
  my_get_version_string = dlsym(ompd_library, "ompd_get_version_string");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_version_string(string);
61}

63OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_finalize(void) {
static ompd_rc_t (*my_ompd_finalize)(void) = NULL((void*)0);
if (!my_ompd_finalize) {
  my_ompd_finalize = dlsym(ompd_library, "ompd_finalize");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_ompd_finalize();
72}

74OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
75ompd_process_initialize(ompd_address_space_context_t *context,
                      ompd_address_space_handle_t **handle) {
static ompd_rc_t (*my_ompd_process_initialize)(
    ompd_address_space_context_t *, ompd_address_space_handle_t **) = NULL((void*)0);
if (!my_ompd_process_initialize) {
  my_ompd_process_initialize = dlsym(ompd_library, "ompd_process_initialize");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_ompd_process_initialize(context, handle);
86}

88OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_omp_version(
  ompd_address_space_handle_t *address_space, ompd_word_t *omp_version) {
static ompd_rc_t (*my_ompd_get_omp_version)(ompd_address_space_handle_t *,
                                            ompd_word_t *) = NULL((void*)0);
if (!my_ompd_get_omp_version) {
  my_ompd_get_omp_version = dlsym(ompd_library, "ompd_get_omp_version");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_ompd_get_omp_version(address_space, omp_version);
99}

101OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_omp_version_string(
  ompd_address_space_handle_t *address_space, const char **string) {
static ompd_rc_t (*my_ompd_get_omp_version_string)(
    ompd_address_space_handle_t *, const char **) = NULL((void*)0);
if (!my_ompd_get_omp_version_string) {
  my_ompd_get_omp_version_string =
      dlsym(ompd_library, "ompd_get_omp_version_string");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_ompd_get_omp_version_string(address_space, string);
113}

115OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_thread_handle(
  ompd_address_space_handle_t *handle, ompd_thread_id_t kind,
  ompd_size_t tidSize, const void *tid, ompd_thread_handle_t **threadHandle) {
static ompd_rc_t (*my_get_thread_handle)(
    ompd_address_space_handle_t *, ompd_thread_id_t, ompd_size_t,
    const void *, ompd_thread_handle_t **) = NULL((void*)0);
if (!my_get_thread_handle) {
  my_get_thread_handle = dlsym(ompd_library, "ompd_get_thread_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_thread_handle(handle, kind, tidSize, tid, threadHandle);
128}

130OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_thread_in_parallel(
  ompd_parallel_handle_t *parallelHandle, int threadNum,
  ompd_thread_handle_t **threadHandle) {
static ompd_rc_t (*my_get_thread_in_parallel)(ompd_parallel_handle_t *, int,
                                              ompd_thread_handle_t **) = NULL((void*)0);
if (!my_get_thread_in_parallel) {
  my_get_thread_in_parallel =
      dlsym(ompd_library, "ompd_get_thread_in_parallel");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_thread_in_parallel(parallelHandle, threadNum, threadHandle);
143}

145OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_thread_handle_compare(
  ompd_thread_handle_t *thread_handle1, ompd_thread_handle_t *thread_handle2,
  int *cmp_value) {
static ompd_rc_t (*my_thread_handle_compare)(
    ompd_thread_handle_t *, ompd_thread_handle_t *, int *) = NULL((void*)0);
if (!my_thread_handle_compare) {
  my_thread_handle_compare =
      dlsym(ompd_library, "ompd_thread_handle_compare");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_thread_handle_compare(thread_handle1, thread_handle2, cmp_value);
158}

160OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
161ompd_get_curr_parallel_handle(ompd_thread_handle_t *threadHandle,
                            ompd_parallel_handle_t **parallelHandle) {
static ompd_rc_t (*my_get_current_parallel_handle)(
    ompd_thread_handle_t *, ompd_parallel_handle_t **) = NULL((void*)0);
if (!my_get_current_parallel_handle) {
  my_get_current_parallel_handle =
      dlsym(ompd_library, "ompd_get_curr_parallel_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_current_parallel_handle(threadHandle, parallelHandle);
173}

175OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_parallel_handle_compare(
  ompd_parallel_handle_t *parallel_handle_1,
  ompd_parallel_handle_t *parallel_handle_2, int *cmp_value) {
static ompd_rc_t (*my_parallel_handle_compare)(
    ompd_parallel_handle_t *, ompd_parallel_handle_t *, int *) = NULL((void*)0);
if (!my_parallel_handle_compare) {
  my_parallel_handle_compare =
      dlsym(ompd_library, "ompd_parallel_handle_compare");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_parallel_handle_compare(parallel_handle_1, parallel_handle_2,
                                  cmp_value);
189}

191OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
192ompd_get_enclosing_parallel_handle(ompd_parallel_handle_t *parallelHandle,
                                 ompd_parallel_handle_t **enclosing) {
static ompd_rc_t (*my_get_enclosing_parallel_handle)(
    ompd_parallel_handle_t *, ompd_parallel_handle_t **) = NULL((void*)0);
if (!my_get_enclosing_parallel_handle) {
  my_get_enclosing_parallel_handle =
      dlsym(ompd_library, "ompd_get_enclosing_parallel_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_enclosing_parallel_handle(parallelHandle, enclosing);
204}

206OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
207ompd_get_task_parallel_handle(ompd_task_handle_t *taskHandle,
                            ompd_parallel_handle_t **taskParallelHandle) {
static ompd_rc_t (*my_get_task_parallel_handle)(
    ompd_task_handle_t *, ompd_parallel_handle_t **) = NULL((void*)0);
if (!my_get_task_parallel_handle) {
  my_get_task_parallel_handle =
      dlsym(ompd_library, "ompd_get_task_parallel_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_task_parallel_handle(taskHandle, taskParallelHandle);
219}

221OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_curr_task_handle(
  ompd_thread_handle_t *threadHandle, ompd_task_handle_t **taskHandle) {
static ompd_rc_t (*my_get_current_task_handle)(ompd_thread_handle_t *,
                                               ompd_task_handle_t **) = NULL((void*)0);
if (!my_get_current_task_handle) {
  my_get_current_task_handle =
      dlsym(ompd_library, "ompd_get_curr_task_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_current_task_handle(threadHandle, taskHandle);
233}

235OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_generating_task_handle(
  ompd_task_handle_t *taskHandle, ompd_task_handle_t **generating) {
static ompd_rc_t (*my_get_generating_task_handle)(
    ompd_task_handle_t *, ompd_task_handle_t **) = NULL((void*)0);
if (!my_get_generating_task_handle) {
  my_get_generating_task_handle =
      dlsym(ompd_library, "ompd_get_generating_task_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_generating_task_handle(taskHandle, generating);
247}

249OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_scheduling_task_handle(
  ompd_task_handle_t *taskHandle, ompd_task_handle_t **scheduling) {
static ompd_rc_t (*my_get_scheduling_task_handle)(
    ompd_task_handle_t *, ompd_task_handle_t **) = NULL((void*)0);
if (!my_get_scheduling_task_handle) {
  my_get_scheduling_task_handle =
      dlsym(ompd_library, "ompd_get_scheduling_task_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_scheduling_task_handle(taskHandle, scheduling);
261}

263OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
264ompd_get_task_in_parallel(ompd_parallel_handle_t *parallelHandle, int threadNum,
                        ompd_task_handle_t **taskHandle) {
static ompd_rc_t (*my_get_task_in_parallel)(ompd_parallel_handle_t *, int,
                                            ompd_task_handle_t **) = NULL((void*)0);
if (!my_get_task_in_parallel) {
  my_get_task_in_parallel = dlsym(ompd_library, "ompd_get_task_in_parallel");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_task_in_parallel(parallelHandle, threadNum, taskHandle);
275}

277OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_task_frame(ompd_task_handle_t *taskHandle,
                                           ompd_frame_info_t *exitFrame,
                                           ompd_frame_info_t *enterFrame) {
static ompd_rc_t (*my_get_task_frame)(
    ompd_task_handle_t *, ompd_frame_info_t *, ompd_frame_info_t *) = NULL((void*)0);
if (!my_get_task_frame) {
  my_get_task_frame = dlsym(ompd_library, "ompd_get_task_frame");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_task_frame(taskHandle, exitFrame, enterFrame);
289}

291OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_icv_from_scope(void *handle,
                                               ompd_scope_t scope,
                                               ompd_icv_id_t icvId,
                                               ompd_word_t *icvValue) {
static ompd_rc_t (*my_get_icv_from_scope)(void *, ompd_scope_t, ompd_icv_id_t,
                                          ompd_word_t *) = NULL((void*)0);
if (!my_get_icv_from_scope) {
  my_get_icv_from_scope = dlsym(ompd_library, "ompd_get_icv_from_scope");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_icv_from_scope(handle, scope, icvId, icvValue);
304}

306OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
307ompd_enumerate_icvs(ompd_address_space_handle_t *handle, ompd_icv_id_t current,
                  ompd_icv_id_t *next, const char **nextIcvName,
                  ompd_scope_t *nextScope, int *more) {
static ompd_rc_t (*my_enumerate_icvs)(
    ompd_address_space_handle_t *, ompd_icv_id_t, ompd_icv_id_t *,
    const char **, ompd_scope_t *, int *) = NULL((void*)0);
if (!my_enumerate_icvs) {
  my_enumerate_icvs = dlsym(ompd_library, "ompd_enumerate_icvs");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_enumerate_icvs(handle, current, next, nextIcvName, nextScope, more);
320}

322OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
323ompd_enumerate_states(ompd_address_space_handle_t *addrSpaceHandle,
                    ompd_word_t currentState, ompd_word_t *nextState,
                    const char **nextStateName, ompd_word_t *moreEnums) {
static ompd_rc_t (*my_enumerate_states)(ompd_address_space_handle_t *,
                                        ompd_word_t, ompd_word_t *,
                                        const char **, ompd_word_t *) = NULL((void*)0);
if (!my_enumerate_states) {
  my_enumerate_states = dlsym(ompd_library, "ompd_enumerate_states");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_enumerate_states(addrSpaceHandle, currentState, nextState,
                           nextStateName, moreEnums);
337}

339OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_state(ompd_thread_handle_t *threadHandle,
                                      ompd_word_t *state,
                                      ompd_wait_id_t *waitId) {
static ompd_rc_t (*my_get_state)(ompd_thread_handle_t *, ompd_word_t *,
                                 ompd_wait_id_t *) = NULL((void*)0);
if (!my_get_state) {
  my_get_state = dlsym(ompd_library, "ompd_get_state");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_state(threadHandle, state, waitId);
351}

353OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_task_function(ompd_task_handle_t *taskHandle,
                                              ompd_address_t *entryPoint) {
static ompd_rc_t (*my_get_task_function)(ompd_task_handle_t *,
                                         ompd_address_t *) = NULL((void*)0);
if (!my_get_task_function) {
  my_get_task_function = dlsym(ompd_library, "ompd_get_task_function");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_task_function(taskHandle, entryPoint);
364}

366OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_thread_id(ompd_thread_handle_t *threadHandle,
                                          ompd_thread_id_t kind,
                                          ompd_size_t tidSize, void *tid) {
static ompd_rc_t (*my_get_thread_id)(ompd_thread_handle_t *, ompd_thread_id_t,
                                     ompd_size_t, void *) = NULL((void*)0);
if (!my_get_thread_id) {
  my_get_thread_id = dlsym(ompd_library, "ompd_get_thread_id");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_thread_id(threadHandle, kind, tidSize, tid);
378}

380OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_get_tool_data(void *handle, ompd_scope_t scope,
                                          ompd_word_t *value,
                                          ompd_address_t *ptr) {
static ompd_rc_t (*my_get_tool_data)(void *, ompd_scope_t, ompd_word_t *,
                                     ompd_address_t *) = NULL((void*)0);
if (!my_get_tool_data) {
  my_get_tool_data = dlsym(ompd_library, "ompd_get_tool_data");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_tool_data(handle, scope, value, ptr);
392}

394OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
395ompd_get_icv_string_from_scope(void *handle, ompd_scope_t scope,
                             ompd_icv_id_t icvId, const char **icvString) {
static ompd_rc_t (*my_get_icv_string_from_scope)(
    void *, ompd_scope_t, ompd_icv_id_t, const char **) = NULL((void*)0);
if (!my_get_icv_string_from_scope) {
  my_get_icv_string_from_scope =
      dlsym(ompd_library, "ompd_get_icv_string_from_scope");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_get_icv_string_from_scope(handle, scope, icvId, icvString);
407}

409OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
410ompd_rel_thread_handle(ompd_thread_handle_t *threadHandle) {
static ompd_rc_t (*my_release_thread_handle)(ompd_thread_handle_t *) = NULL((void*)0);
if (!my_release_thread_handle) {
  my_release_thread_handle = dlsym(ompd_library, "ompd_rel_thread_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_release_thread_handle(threadHandle);
419}

421OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
422ompd_rel_parallel_handle(ompd_parallel_handle_t *parallelHandle) {
static ompd_rc_t (*my_release_parallel_handle)(ompd_parallel_handle_t *) =
    NULL((void*)0);
if (!my_release_parallel_handle) {
  my_release_parallel_handle =
      dlsym(ompd_library, "ompd_rel_parallel_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_release_parallel_handle(parallelHandle);
433}

435OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t ompd_rel_task_handle(ompd_task_handle_t *taskHandle) {
static ompd_rc_t (*my_release_task_handle)(ompd_task_handle_t *) = NULL((void*)0);
if (!my_release_task_handle) {
  my_release_task_handle = dlsym(ompd_library, "ompd_rel_task_handle");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_release_task_handle(taskHandle);
444}

446OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
447ompd_task_handle_compare(ompd_task_handle_t *task_handle_1,
                       ompd_task_handle_t *task_handle_2, int *cmp_value) {
static ompd_rc_t (*my_task_handle_compare)(
    ompd_task_handle_t *, ompd_task_handle_t *, int *) = NULL((void*)0);
if (!my_task_handle_compare) {
  my_task_handle_compare = dlsym(ompd_library, "ompd_task_handle_compare");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_task_handle_compare(task_handle_1, task_handle_2, cmp_value);
458}

460OMPD_WEAK_ATTR__attribute__((weak)) ompd_rc_t
461ompd_get_display_control_vars(ompd_address_space_handle_t *address_space_handle,
                            const char *const **control_vars) {
static ompd_rc_t (*my_ompd_get_display_control_vars)(
    ompd_address_space_handle_t *, const char *const **) = NULL((void*)0);
if (!my_ompd_get_display_control_vars) {
  my_ompd_get_display_control_vars =
      dlsym(ompd_library, "ompd_get_display_control_vars");
  if (dlerror()) {
    return ompd_rc_error;
  }
}
return my_ompd_get_display_control_vars(address_space_handle, control_vars);
473}

475/**
* Loads the OMPD library (libompd.so). Returns an integer with the version if
* the OMPD library could be loaded successfully. Error codes: -1: argument
* could not be converted to string -2: error when calling dlopen -3: error when
* fetching version of OMPD API else: see ompd return codes
*/
481static PyObject *ompd_open(PyObject *self, PyObject *args) {
const char *name, *dlerr;
dlerror();
if (!PyArg_ParseTuple(args, "s", &name)) {
  return Py_BuildValue("i", -1);
}
ompd_library = dlopen(name, RTLD_LAZY0x00001);
if ((dlerr = dlerror())) {
  return Py_BuildValue("i", -2);
}
if (dlerror()) {
  return Py_BuildValue("i", -3);
}
ompd_word_t version;
ompd_rc_t rc = ompd_get_api_version(&version);
if (rc != ompd_rc_ok)
  return Py_BuildValue("l", -10 - rc);

int returnValue = version;
return Py_BuildValue("i", returnValue);
501}

503/**
* Have the debugger print a string.
*/
506ompd_rc_t _print(const char *str, int category) {
PyObject *pFunc = PyObject_GetAttrString(pModule, "_print");
if (pFunc && PyCallable_Check(pFunc)) {
  PyObject *pArgs = PyTuple_New(1);
  PyTuple_SetItem(pArgs, 0, Py_BuildValue("s", str));
  PyObject_CallObject(pFunc, pArgs);
  Py_XDECREF(pArgs)_Py_XDECREF(((PyObject*)(pArgs)));
}
Py_XDECREF(pFunc)_Py_XDECREF(((PyObject*)(pFunc)));
return ompd_rc_ok;
516}

518void _printf(const char *format, ...) {
va_list args;
va_start(args, format)__builtin_va_start(args, format);
char output[1024];
vsnprintf(output, 1024, format, args);
va_end(args)__builtin_va_end(args);
_print(output, 0);
525}

527/**
* Capsule destructors for thread, parallel and task handles.
*/
530static void call_ompd_rel_thread_handle_temp(PyObject *capsule) {
ompd_thread_handle_t *threadHandle =
    (ompd_thread_handle_t *)(PyCapsule_GetPointer(capsule, "ThreadHandle"));

ompd_rc_t retVal = ompd_rel_thread_handle(threadHandle);
if (retVal != ompd_rc_ok) {
  _printf(
      "An error occurred when calling ompd_rel_thread_handle! Error code: %d",
      retVal);
}
540}

542static void destroyThreadCapsule(PyObject *capsule) {
call_ompd_rel_thread_handle_temp(capsule);
544}
545static void (*my_thread_capsule_destructor)(PyObject *) = destroyThreadCapsule;

547static void call_ompd_rel_parallel_handle_temp(PyObject *capsule) {
ompd_parallel_handle_t *parallelHandle =
    (ompd_parallel_handle_t *)(PyCapsule_GetPointer(capsule,
                                                    "ParallelHandle"));

ompd_rc_t retVal = ompd_rel_parallel_handle(parallelHandle);
if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_rel_parallel_handle! Error "
          "code: %d",
          retVal);
}
558}

560static void destroyParallelCapsule(PyObject *capsule) {
call_ompd_rel_parallel_handle_temp(capsule);
562}
563static void (*my_parallel_capsule_destructor)(PyObject *) =
  destroyParallelCapsule;

566static void call_ompd_rel_task_handle_temp(PyObject *capsule) {
ompd_task_handle_t *taskHandle =
    (ompd_task_handle_t *)(PyCapsule_GetPointer(capsule, "TaskHandle"));

ompd_rc_t retVal = ompd_rel_task_handle(taskHandle);
if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_rel_task_handle!\n");
}
574}

576static void destroyTaskCapsule(PyObject *capsule) {
call_ompd_rel_task_handle_temp(capsule);
578}
579static void (*my_task_capsule_destructor)(PyObject *) = destroyTaskCapsule;

581/**
* Release thread handle. Called inside destructor for Python thread_handle
* object.
*/
585static PyObject *call_ompd_rel_thread_handle(PyObject *self, PyObject *args) {
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
ompd_thread_handle_t *threadHandle =
    (ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
                                                  "ThreadHandle"));

ompd_rc_t retVal = ompd_rel_thread_handle(threadHandle);
if (retVal != ompd_rc_ok) {
  _printf(
      "An error occurred when calling ompd_rel_thread_handle! Error code: %d",
      retVal);
}
return Py_BuildValue("l", retVal);
598}

600/**
* Allocate memory in the debugger's address space.
*/
603ompd_rc_t _alloc(ompd_size_t bytes, void **ptr) {
if (ptr == NULL((void*)0)) {
  return ompd_rc_bad_input;
}
*ptr = malloc(bytes);
return ompd_rc_ok;
609}

611/**
* Free memory in the debugger's address space.
*/
614ompd_rc_t _free(void *ptr) {
free(ptr);
return ompd_rc_ok;
617}

619/**
* Look up the sizes of primitive types in the target.
*/
622ompd_rc_t _sizes(ompd_address_space_context_t *_acontext, /* IN */
               ompd_device_type_sizes_t *sizes)         /* OUT */
624{
if (acontext.id != _acontext->id)
  return ompd_rc_stale_handle;
ompd_device_type_sizes_t mysizes = {
    (uint8_t)sizeof(char),      (uint8_t)sizeof(short),
    (uint8_t)sizeof(int),       (uint8_t)sizeof(long),
    (uint8_t)sizeof(long long), (uint8_t)sizeof(void *)};
*sizes = mysizes;
return ompd_rc_ok;
633}

635/**
* Look up the address of a global symbol in the target.
*/
638ompd_rc_t _sym_addr(ompd_address_space_context_t *context, /* IN */
                  ompd_thread_context_t *tcontext,       /* IN */
                  const char *symbol_name,               /* IN */
                  ompd_address_t *symbol_addr,           /* OUT */
                  const char *file_name)                 /* IN */
643{
int thread_id = -1;
PyObject *symbolAddress;
if (tcontext != NULL((void*)0)) {
  thread_id = tcontext->id;
}
PyObject *pFunc = PyObject_GetAttrString(pModule, "_sym_addr");
if (pFunc && PyCallable_Check(pFunc)) {
  PyObject *pArgs = PyTuple_New(2);
  PyTuple_SetItem(pArgs, 0, Py_BuildValue("i", thread_id));
  PyTuple_SetItem(pArgs, 1, Py_BuildValue("s", symbol_name));
  symbolAddress = PyObject_CallObject(pFunc, pArgs);
  if (symbolAddress == NULL((void*)0)) {
    PyErr_Print();
  }
  symbol_addr->address = PyLong_AsLong(symbolAddress);
  Py_XDECREF(pArgs)_Py_XDECREF(((PyObject*)(pArgs)));
  Py_XDECREF(symbolAddress)_Py_XDECREF(((PyObject*)(symbolAddress)));
}
Py_XDECREF(pFunc)_Py_XDECREF(((PyObject*)(pFunc)));
return ompd_rc_ok;
664}

666/**
* Read memory from the target.
*/
669ompd_rc_t _read(ompd_address_space_context_t *context, /* IN */
              ompd_thread_context_t *tcontext,       /* IN */
              const ompd_address_t *addr,            /* IN */
              ompd_size_t nbytes,                    /* IN */
              void *buffer)                          /* OUT */
674{
uint64_t readMem = (uint64_t)addr->address;
PyObject *pFunc = PyObject_GetAttrString(pModule, "_read");
if (pFunc && PyCallable_Check(pFunc)) {
1
Assuming 'pFunc' is non-null→
2
←
Assuming the condition is true→
3
←
Taking true branch→
  PyObject *pArgs = PyTuple_New(2);
  PyTuple_SetItem(pArgs, 0, Py_BuildValue("l", readMem));
  PyTuple_SetItem(pArgs, 1, Py_BuildValue("l", nbytes));
  PyObject *retArray = PyObject_CallObject(pFunc, pArgs);
4
←
'retArray' initialized here→
  Py_XDECREF(pArgs)_Py_XDECREF(((PyObject*)(pArgs)));
  if (retArray == NULL((void*)0)) {
5
←
Assuming 'retArray' is equal to NULL→
6
←
Taking true branch→
    PyErr_Print();
  }
  if (!PyByteArray_Check(retArray)(_Py_IS_TYPE(((const PyObject*)(retArray)), &PyByteArray_Type
) || PyType_IsSubtype((((PyObject*)(retArray))->ob_type), (
&PyByteArray_Type)))) {
7
←
Passing null pointer value via 1st parameter 'ob'→
8
←
Calling '_Py_IS_TYPE'→
    return ompd_rc_error;
  }
  Py_ssize_t retSize = PyByteArray_Size(retArray);
  const char *strBuf = PyByteArray_AsString(retArray);
  if ((ompd_size_t)retSize != nbytes) {
    return ompd_rc_error;
  }
  memcpy(buffer, strBuf, nbytes);
  Py_XDECREF(retArray)_Py_XDECREF(((PyObject*)(retArray)));
}
Py_XDECREF(pFunc)_Py_XDECREF(((PyObject*)(pFunc)));
return ompd_rc_ok;
699}

701/**
* Reads string from target.
*/
704ompd_rc_t _read_string(ompd_address_space_context_t *context, /* IN */
                     ompd_thread_context_t *tcontext,       /* IN */
                     const ompd_address_t *addr,            /* IN */
                     ompd_size_t nbytes,                    /* IN */
                     void *buffer)                          /* OUT */
709{
ompd_rc_t retVal = ompd_rc_ok;
uint64_t readMem = (uint64_t)addr->address;
PyObject *pFunc = PyObject_GetAttrString(pModule, "_read_string");
PyObject *pArgs = PyTuple_New(1);
PyTuple_SetItem(pArgs, 0, Py_BuildValue("l", readMem));
PyObject *retString = PyObject_CallObject(pFunc, pArgs);
Py_XDECREF(pArgs)_Py_XDECREF(((PyObject*)(pArgs)));
if (!PyUnicode_Check(retString)PyType_HasFeature((((PyObject*)(retString))->ob_type), (1UL
 << 28))) {
  return ompd_rc_error;
}
Py_ssize_t retSize;
const char *strbuffer = PyUnicode_AsUTF8AndSize(retString, &retSize);
if ((ompd_size_t)retSize + 1 >= nbytes) {
  retVal = ompd_rc_incomplete;
}
strncpy(buffer, strbuffer, nbytes);
((char *)buffer)[nbytes - 1] = '\0';
return retVal;
728}

730/**
* Write memory from the target.
*/
733ompd_rc_t
734_endianess(ompd_address_space_context_t *address_space_context, /* IN */
         const void *input,                                   /* IN */
         ompd_size_t unit_size,                               /* IN */
         ompd_size_t count, /* IN: number of primitive type */
         void *output) {
if (acontext.id != address_space_context->id)
  return ompd_rc_stale_handle;
memmove(output, input, count * unit_size);
return ompd_rc_ok;
743}

745/**
* Returns thread context for thread id; helper function for _thread_context
* callback.
*/
749ompd_thread_context_t *get_thread_context(int id) {
static ompd_thread_context_t *tc = NULL((void*)0);
static int size = 0;
int i;
if (id < 1)
  return NULL((void*)0);
if (tc == NULL((void*)0)) {
  size = 16;
  tc = malloc(size * sizeof(ompd_thread_context_t));
  for (i = 0; i < size; i++)
    tc[i].id = i + 1;
}
if (id - 1 >= size) {
  size += 16;
  tc = realloc(tc, size * sizeof(ompd_thread_context_t));
  for (i = 0; i < size; i++)
    tc[i].id = i + 1;
}
return tc + id - 1;
768}

770/**
* Get thread specific context.
*/
773ompd_rc_t
774_thread_context(ompd_address_space_context_t *context, /* IN */
              ompd_thread_id_t kind,        /* IN, 0 for pthread, 1 for lwp */
              ompd_size_t sizeof_thread_id, /* IN */
              const void *thread_id,        /* IN */
              ompd_thread_context_t **thread_context) /* OUT */
779{
if (acontext.id != context->id)
  return ompd_rc_stale_handle;
if (kind != 0 && kind != 1)
  return ompd_rc_unsupported;
long int tid;
if (sizeof(long int) >= 8 && sizeof_thread_id == 8)
  tid = *(const uint64_t *)thread_id;
else if (sizeof(long int) >= 4 && sizeof_thread_id == 4)
  tid = *(const uint32_t *)thread_id;
else if (sizeof(long int) >= 2 && sizeof_thread_id == 2)
  tid = *(const uint16_t *)thread_id;
else
  return ompd_rc_bad_input;
PyObject *pFunc = PyObject_GetAttrString(pModule, "_thread_context");
if (pFunc && PyCallable_Check(pFunc)) {
  PyObject *pArgs = PyTuple_New(2);
  PyTuple_SetItem(pArgs, 0, Py_BuildValue("l", kind));
  PyTuple_SetItem(pArgs, 1, Py_BuildValue("l", tid));
  PyObject *res = PyObject_CallObject(pFunc, pArgs);
  int resAsInt = (int)PyLong_AsLong(res);
  if (resAsInt == -1) {
    // NOTE: could not find match for thread_id
    return ompd_rc_unavailable;
  }
  (*thread_context) = get_thread_context(resAsInt);
  Py_XDECREF(pArgs)_Py_XDECREF(((PyObject*)(pArgs)));
  Py_XDECREF(res)_Py_XDECREF(((PyObject*)(res)));
  Py_XDECREF(pFunc)_Py_XDECREF(((PyObject*)(pFunc)));
  if (*thread_context == NULL((void*)0)) {
    return ompd_rc_bad_input;
  }
  return ompd_rc_ok;
}
Py_XDECREF(pFunc)_Py_XDECREF(((PyObject*)(pFunc)));
return ompd_rc_error;
815}

817/**
* Calls ompd_process_initialize; returns pointer to ompd_address_space_handle.
*/
820static PyObject *call_ompd_initialize(PyObject *self, PyObject *noargs) {
pModule = PyImport_Import(PyUnicode_FromString("ompd_callbacks"));

static ompd_callbacks_t table = {
    _alloc, _free,        _print,     _sizes,     _sym_addr,      _read,
    NULL((void*)0),   _read_string, _endianess, _endianess, _thread_context};

ompd_rc_t (*my_ompd_init)(ompd_word_t version, ompd_callbacks_t *) =
    dlsym(ompd_library, "ompd_initialize");
ompd_rc_t returnInit = my_ompd_init(201811, &table);
if (returnInit != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_initialize! Error code: %d",
          returnInit);
}
ompd_address_space_handle_t *addr_space = NULL((void*)0);
ompd_rc_t (*my_proc_init)(ompd_address_space_context_t *,
                          ompd_address_space_handle_t **) =
    dlsym(ompd_library, "ompd_process_initialize");
ompd_rc_t retProcInit = my_proc_init(&acontext, &addr_space);
if (retProcInit != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_process_initialize! Error "
          "code: %d",
          retProcInit);
}
return PyCapsule_New(addr_space, "AddressSpace", NULL((void*)0));
845}

847/**
* Returns a PyCapsule pointer to thread handle for thread with the given id.
*/
850static PyObject *get_thread_handle(PyObject *self, PyObject *args) {
PyObject *threadIdTup = PyTuple_GetItem(args, 0);
uint64_t threadId = (uint64_t)PyLong_AsLong(threadIdTup);
// NOTE: compiler does not know what thread handle looks like, so no memory
// is allocated automatically in the debugger's memory space

PyObject *addrSpaceTup = PyTuple_GetItem(args, 1);
ompd_thread_handle_t *threadHandle;
ompd_address_space_handle_t *addrSpace =
    (ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
                                                        "AddressSpace");

ompd_size_t sizeof_tid = (ompd_size_t)sizeof(uint64_t);
ompd_rc_t retVal = ompd_get_thread_handle(addrSpace, 1, sizeof_tid, &threadId,
                                          &threadHandle);

if (retVal == ompd_rc_unavailable) {
  return Py_BuildValue("i", -1);
} else if (retVal != ompd_rc_ok) {
  _printf(
      "An error occured when calling ompd_get_thread_handle! Error code: %d",
      retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(threadHandle, "ThreadHandle",
                     my_thread_capsule_destructor);
876}

878/**
* Returns a PyCapsule pointer to a thread handle for a specific thread id in
* the current parallel context.
*/
882static PyObject *call_ompd_get_thread_in_parallel(PyObject *self,
                                                PyObject *args) {
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
int threadNum = (int)PyLong_AsLong(PyTuple_GetItem(args, 1));
ompd_parallel_handle_t *parallelHandle =
    (ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
                                                    "ParallelHandle"));
ompd_thread_handle_t *threadHandle;

ompd_rc_t retVal =
    ompd_get_thread_in_parallel(parallelHandle, threadNum, &threadHandle);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_thread_in_parallel! Error "
          "code: %d",
          retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(threadHandle, "ThreadHandle",
                     my_thread_capsule_destructor);
902}

904/**
* Returns a PyCapsule pointer to the parallel handle of the current parallel
* region associated with a thread.
*/
908static PyObject *call_ompd_get_curr_parallel_handle(PyObject *self,
                                                  PyObject *args) {
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
ompd_thread_handle_t *threadHandle =
    (ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
                                                  "ThreadHandle"));
ompd_parallel_handle_t *parallelHandle;

ompd_rc_t retVal =
    ompd_get_curr_parallel_handle(threadHandle, &parallelHandle);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_curr_parallel_handle! "
          "Error code: %d",
          retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(parallelHandle, "ParallelHandle",
                     my_parallel_capsule_destructor);
927}

929/**
* Returns a PyCapsule pointer to the parallel  handle for the parallel region
* enclosing the parallel region specified by parallel_handle.
*/
933static PyObject *call_ompd_get_enclosing_parallel_handle(PyObject *self,
                                                       PyObject *args) {
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
ompd_parallel_handle_t *parallelHandle =
    (ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
                                                    "ParallelHandle"));
ompd_parallel_handle_t *enclosingParallelHandle;

ompd_rc_t retVal = ompd_get_enclosing_parallel_handle(
    parallelHandle, &enclosingParallelHandle);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling "
          "ompd_get_enclosing_parallel_handle! Error code: %d",
          retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(enclosingParallelHandle, "ParallelHandle",
                     my_parallel_capsule_destructor);
952}

954/**
* Returns a PyCapsule pointer to the parallel handle for the parallel region
* enclosing the task specified.
*/
958static PyObject *call_ompd_get_task_parallel_handle(PyObject *self,
                                                  PyObject *args) {
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
ompd_task_handle_t *taskHandle =
    PyCapsule_GetPointer(taskHandlePy, "TaskHandle");
ompd_parallel_handle_t *taskParallelHandle;

ompd_rc_t retVal =
    ompd_get_task_parallel_handle(taskHandle, &taskParallelHandle);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_task_parallel_handle! "
          "Error code: %d");
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(taskParallelHandle, "ParallelHandle",
                     my_parallel_capsule_destructor);
975}

977/**
* Releases a parallel handle; is called in by the destructor of a Python
* parallel_handle object.
*/
981static PyObject *call_ompd_rel_parallel_handle(PyObject *self, PyObject *args) {
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
ompd_parallel_handle_t *parallelHandle =
    (ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
                                                    "ParallelHandle"));

ompd_rc_t retVal = ompd_rel_parallel_handle(parallelHandle);
if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_rel_parallel_handle! Error "
          "code: %d",
          retVal);
}
return Py_BuildValue("l", retVal);
994}

996/**
* Returns a PyCapsule pointer to the task handle of the current task region
* associated with a thread.
*/
1000static PyObject *call_ompd_get_curr_task_handle(PyObject *self,
                                              PyObject *args) {
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
ompd_thread_handle_t *threadHandle =
    (ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
                                                  "ThreadHandle"));
ompd_task_handle_t *taskHandle;

ompd_rc_t retVal = ompd_get_curr_task_handle(threadHandle, &taskHandle);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_curr_task_handle! Error "
          "code: %d",
          retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(taskHandle, "TaskHandle", my_task_capsule_destructor);
1017}

1019/**
* Returns a task handle for the task that created the task specified.
*/
1022static PyObject *call_ompd_get_generating_task_handle(PyObject *self,
                                                    PyObject *args) {
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
ompd_task_handle_t *taskHandle =
    (ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));
ompd_task_handle_t *generatingTaskHandle;

ompd_rc_t retVal =
    ompd_get_generating_task_handle(taskHandle, &generatingTaskHandle);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_generating_task_handle! "
          "Error code: %d",
          retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(generatingTaskHandle, "TaskHandle",
                     my_task_capsule_destructor);
1040}

1042/**
* Returns the task handle for the task that scheduled the task specified.
*/
1045static PyObject *call_ompd_get_scheduling_task_handle(PyObject *self,
                                                    PyObject *args) {
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
ompd_task_handle_t *taskHandle =
    (ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));
ompd_task_handle_t *schedulingTaskHandle;

ompd_rc_t retVal =
    ompd_get_scheduling_task_handle(taskHandle, &schedulingTaskHandle);

if (retVal == ompd_rc_unavailable) {
  return Py_None(&_Py_NoneStruct);
} else if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_scheduling_task_handle! "
          "Error code: %d",
          retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(schedulingTaskHandle, "TaskHandle",
                     my_task_capsule_destructor);
1065}

1067/**
* Returns task handles for the implicit tasks associated with a parallel
* region.
*/
1071static PyObject *call_ompd_get_task_in_parallel(PyObject *self,
                                              PyObject *args) {
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
int threadNum = (int)PyLong_AsLong(PyTuple_GetItem(args, 1));
ompd_parallel_handle_t *parallelHandle =
    (ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
                                                    "ParallelHandle"));
ompd_task_handle_t *taskHandle;

ompd_rc_t retVal =
    ompd_get_task_in_parallel(parallelHandle, threadNum, &taskHandle);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_task_in_parallel! Error "
          "code: %d",
          retVal);
  return Py_BuildValue("l", retVal);
}
return PyCapsule_New(taskHandle, "TaskHandle", my_task_capsule_destructor);
1090}

1092/**
* Releases a task handle; is called by the destructor of a Python task_handle
* object.
*/
1096static PyObject *call_ompd_rel_task_handle(PyObject *self, PyObject *args) {
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
ompd_task_handle_t *taskHandle =
    (ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));

ompd_rc_t retVal = ompd_rel_task_handle(taskHandle);
if (retVal != ompd_rc_ok) {
  _printf(
      "An error occurred when calling ompd_rel_task_handle! Error code: %d",
      retVal);
}
return Py_BuildValue("l", retVal);
1108}

1110/**
* Calls ompd_get_task_frame and returns a PyCapsule for the enter frame of the
* given task.
*/
1114static PyObject *call_ompd_get_task_frame(PyObject *self, PyObject *args) {
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
ompd_task_handle_t *taskHandle =
    (ompd_task_handle_t *)PyCapsule_GetPointer(taskHandlePy, "TaskHandle");
ompd_frame_info_t exitFrameInfo;
ompd_frame_info_t enterFrameInfo;

ompd_rc_t retVal =
    ompd_get_task_frame(taskHandle, &exitFrameInfo, &enterFrameInfo);

if (retVal != ompd_rc_ok) {
  _printf(
      "An error occurred when calling ompd_get_task_frame! Error code: %d",
      retVal);
  return Py_BuildValue("l", retVal);
}

PyObject *result = PyTuple_New(4);
PyTuple_SetItem(
    result, 0, PyLong_FromUnsignedLong(enterFrameInfo.frame_address.address));
PyTuple_SetItem(result, 1,
                PyLong_FromUnsignedLong(enterFrameInfo.frame_flag));
PyTuple_SetItem(result, 2,
                PyLong_FromUnsignedLong(exitFrameInfo.frame_address.address));
PyTuple_SetItem(result, 3, PyLong_FromUnsignedLong(exitFrameInfo.frame_flag));
return result;
1140}

1142/**
* Calls ompd_get_icv_from_scope.
*/
1145static PyObject *call_ompd_get_icv_from_scope(PyObject *self, PyObject *args) {
PyObject *addrSpaceHandlePy = PyTuple_GetItem(args, 0);
PyObject *scopePy = PyTuple_GetItem(args, 1);
PyObject *icvIdPy = PyTuple_GetItem(args, 2);

ompd_scope_t scope = (ompd_scope_t)PyLong_AsLong(scopePy);
ompd_address_space_handle_t *addrSpaceHandle;
switch (scope) {
case ompd_scope_thread:
  addrSpaceHandle = (ompd_address_space_handle_t *)PyCapsule_GetPointer(
      addrSpaceHandlePy, "ThreadHandle");
  break;
case ompd_scope_parallel:
  addrSpaceHandle = (ompd_address_space_handle_t *)PyCapsule_GetPointer(
      addrSpaceHandlePy, "ParallelHandle");
  break;
case ompd_scope_implicit_task:
  addrSpaceHandle = (ompd_address_space_handle_t *)PyCapsule_GetPointer(
      addrSpaceHandlePy, "TaskHandle");
  break;
case ompd_scope_task:
  addrSpaceHandle = (ompd_address_space_handle_t *)PyCapsule_GetPointer(
      addrSpaceHandlePy, "TaskHandle");
  break;
default:
  addrSpaceHandle = (ompd_address_space_handle_t *)PyCapsule_GetPointer(
      addrSpaceHandlePy, "AddressSpace");
  break;
}

ompd_icv_id_t icvId = (ompd_icv_id_t)PyLong_AsLong(icvIdPy);
ompd_word_t icvValue;

ompd_rc_t retVal =
    ompd_get_icv_from_scope(addrSpaceHandle, scope, icvId, &icvValue);

if (retVal != ompd_rc_ok) {
  if (retVal != ompd_rc_incomplete) {
    _printf("An error occurred when calling ompd_get_icv_from_scope(%i, %i): "
            "Error code: %d",
            scope, icvId, retVal);
  }
  return Py_None(&_Py_NoneStruct);
}
return PyLong_FromLong(icvValue);
1190}

1192/**
* Calls ompd_enumerate_icvs.
*/
1195static PyObject *call_ompd_enumerate_icvs(PyObject *self, PyObject *args) {
PyObject *addrSpaceHandlePy = PyTuple_GetItem(args, 0);
PyObject *currentPy = PyTuple_GetItem(args, 1);
ompd_icv_id_t current = (ompd_icv_id_t)(PyLong_AsLong(currentPy));
ompd_address_space_handle_t *addrSpaceHandle =
    (ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceHandlePy,
                                                        "AddressSpace");

const char *nextIcv;
ompd_scope_t nextScope;
int more;
ompd_icv_id_t nextId;

ompd_rc_t retVal = ompd_enumerate_icvs(addrSpaceHandle, current, &nextId,
                                       &nextIcv, &nextScope, &more);

if (retVal != ompd_rc_ok) {
  _printf(
      "An error occurred when calling ompd_enumerate_icvs! Error code: %d",
      retVal);
  return Py_None(&_Py_NoneStruct);
}
PyObject *retTuple = PyTuple_New(4);
PyTuple_SetItem(retTuple, 0, PyLong_FromUnsignedLong(nextId));
PyTuple_SetItem(retTuple, 1, PyUnicode_FromString(nextIcv));
PyTuple_SetItem(retTuple, 2, PyLong_FromUnsignedLong(nextScope));
PyTuple_SetItem(retTuple, 3, PyLong_FromLong(more));
return retTuple;
1223}

1225/**
* Calls ompd_enumerate_states.
*/
1228static PyObject *call_ompd_enumerate_states(PyObject *self, PyObject *args) {
PyObject *addrSpaceHandlePy = PyTuple_GetItem(args, 0);
ompd_address_space_handle_t *addrSpaceHandle =
    (ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceHandlePy,
                                                        "AddressSpace");
ompd_word_t currentState =
    (ompd_word_t)PyLong_AsLong(PyTuple_GetItem(args, 1));

ompd_word_t nextState;
const char *nextStateName;
ompd_word_t moreEnums;

ompd_rc_t retVal = ompd_enumerate_states(
    addrSpaceHandle, currentState, &nextState, &nextStateName, &moreEnums);

if (retVal != ompd_rc_ok) {
  _printf(
      "An error occurred when calling ompd_enumerate_states! Error code: %d",
      retVal);
  return Py_None(&_Py_NoneStruct);
}
PyObject *retTuple = PyTuple_New(3);
PyTuple_SetItem(retTuple, 0, PyLong_FromLong(nextState));
PyTuple_SetItem(retTuple, 1, PyUnicode_FromString(nextStateName));
PyTuple_SetItem(retTuple, 2, PyLong_FromLong(moreEnums));
return retTuple;
1254}

1256/**
* Calls ompd_get_state.
*/
1259static PyObject *call_ompd_get_state(PyObject *self, PyObject *args) {
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
ompd_thread_handle_t *threadHandle =
    (ompd_thread_handle_t *)PyCapsule_GetPointer(threadHandlePy,
                                                 "ThreadHandle");
ompd_word_t state;
ompd_wait_id_t waitId;

ompd_rc_t retVal = ompd_get_state(threadHandle, &state, &waitId);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_state! Error code: %d",
          retVal);
  return Py_None(&_Py_NoneStruct);
}
PyObject *retTuple = PyTuple_New(2);
PyTuple_SetItem(retTuple, 0, PyLong_FromLong(state));
PyTuple_SetItem(retTuple, 1, PyLong_FromUnsignedLong(waitId));
return retTuple;
1278}

1280/**
* Calls ompd_get_task_function and returns entry point of the code that
* corresponds to the code executed by the task.
*/
1284static PyObject *call_ompd_get_task_function(PyObject *self, PyObject *args) {
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
ompd_task_handle_t *taskHandle =
    (ompd_task_handle_t *)PyCapsule_GetPointer(taskHandlePy, "TaskHandle");
ompd_address_t entryPoint;

ompd_rc_t retVal = ompd_get_task_function(taskHandle, &entryPoint);

if (retVal != ompd_rc_ok) {
  _printf(
      "An error occurred when calling ompd_get_task_function! Error code: %d",
      retVal);
  return Py_None(&_Py_NoneStruct);
}
return PyLong_FromLong((long)entryPoint.address);
1299}

1301/**
* Prints pointer stored inside PyCapusle.
*/
1304static PyObject *print_capsule(PyObject *self, PyObject *args) {
PyObject *capsule = PyTuple_GetItem(args, 0);
PyObject *name = PyTuple_GetItem(args, 1);
void *pointer =
    PyCapsule_GetPointer(capsule, PyUnicode_AsUTF8AndSize(name, NULL((void*)0)));
_printf("Capsule pointer: %p", pointer);
return Py_None(&_Py_NoneStruct);
1311}

1313/**
* Calls ompd_get_thread_id for given handle and returns the thread id as a
* long.
*/
1317static PyObject *call_ompd_get_thread_id(PyObject *self, PyObject *args) {
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
ompd_thread_handle_t *threadHandle =
    (ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
                                                  "ThreadHandle"));
ompd_thread_id_t kind = 0; // OMPD_THREAD_ID_PTHREAD
ompd_size_t sizeOfId = (ompd_size_t)sizeof(pthread_t);

uint64_t thread;
ompd_rc_t retVal = ompd_get_thread_id(threadHandle, kind, sizeOfId, &thread);

if (retVal != ompd_rc_ok) {
  kind = 1; // OMPD_THREAD_ID_LWP
  retVal = ompd_get_thread_id(threadHandle, kind, sizeOfId, &thread);
  if (retVal != ompd_rc_ok) {
    _printf(
        "An error occurred when calling ompd_get_thread_id! Error code: %d",
        retVal);
    return Py_None(&_Py_NoneStruct);
  }
}
return PyLong_FromLong(thread);
1339}

1341/**
* Calls ompd_get_tool_data and returns a tuple containing the value and pointer
* of the ompt_data_t union for the selected scope.
*/
1345static PyObject *call_ompd_get_tool_data(PyObject *self, PyObject *args) {
PyObject *scopePy = PyTuple_GetItem(args, 0);
ompd_scope_t scope = (ompd_scope_t)(PyLong_AsLong(scopePy));
PyObject *handlePy = PyTuple_GetItem(args, 1);
void *handle = NULL((void*)0);

if (scope == 3) {
  ompd_thread_handle_t *threadHandle =
      (ompd_thread_handle_t *)(PyCapsule_GetPointer(handlePy,
                                                    "ThreadHandle"));
  handle = threadHandle;
} else if (scope == 4) {
  ompd_parallel_handle_t *parallelHandle =
      (ompd_parallel_handle_t *)(PyCapsule_GetPointer(handlePy,
                                                      "ParallelHandle"));
  handle = parallelHandle;
} else if (scope == 5 || scope == 6) {
  ompd_task_handle_t *taskHandle =
      (ompd_task_handle_t *)(PyCapsule_GetPointer(handlePy, "TaskHandle"));
  handle = taskHandle;
} else {
  _printf("An error occured when calling ompd_get_tool_data! Scope type not "
          "supported.");
  return Py_None(&_Py_NoneStruct);
}

ompd_word_t value;
ompd_address_t ptr;

ompd_rc_t retVal = ompd_get_tool_data(handle, scope, &value, &ptr);

if (retVal != ompd_rc_ok) {
  _printf("An error occured when calling ompd_get_tool_data! Error code: %d",
          retVal);
  return Py_None(&_Py_NoneStruct);
}

PyObject *retTuple = PyTuple_New(2);
PyTuple_SetItem(retTuple, 0, PyLong_FromLong(value));
PyTuple_SetItem(retTuple, 1, PyLong_FromLong(ptr.address));
return retTuple;
1386}

1388/** Calls ompd_get_icv_string_from_scope.
*/
1390static PyObject *call_ompd_get_icv_string_from_scope(PyObject *self,
                                                   PyObject *args) {
PyObject *handlePy = PyTuple_GetItem(args, 0);
PyObject *scopePy = PyTuple_GetItem(args, 1);
PyObject *icvIdPy = PyTuple_GetItem(args, 2);

ompd_scope_t scope = (ompd_scope_t)PyLong_AsLong(scopePy);
void *handle = NULL((void*)0);
switch (scope) {
case ompd_scope_thread:
  handle =
      (ompd_thread_handle_t *)PyCapsule_GetPointer(handlePy, "ThreadHandle");
  break;
case ompd_scope_parallel:
  handle = (ompd_parallel_handle_t *)PyCapsule_GetPointer(handlePy,
                                                          "ParallelHandle");
  break;
case ompd_scope_implicit_task:
  handle = (ompd_task_handle_t *)PyCapsule_GetPointer(handlePy, "TaskHandle");
  break;
case ompd_scope_task:
  handle = (ompd_task_handle_t *)PyCapsule_GetPointer(handlePy, "TaskHandle");
  break;
default:
  handle = (ompd_address_space_handle_t *)PyCapsule_GetPointer(
      handlePy, "AddressSpace");
  break;
}

ompd_icv_id_t icvId = (ompd_icv_id_t)PyLong_AsLong(icvIdPy);
const char *icvString;

ompd_rc_t retVal =
    ompd_get_icv_string_from_scope(handle, scope, icvId, &icvString);

if (retVal != ompd_rc_ok) {
  _printf("An error occurred when calling ompd_get_icv_string_from_scope! "
          "Error code: %d",
          retVal);
  return Py_None(&_Py_NoneStruct);
}
return PyUnicode_FromString(icvString);
1432}

1434// Prototypes of API test functions.
1435PyObject *test_ompd_get_thread_handle(PyObject *self, PyObject *args);
1436PyObject *test_ompd_get_curr_parallel_handle(PyObject *self, PyObject *args);
1437PyObject *test_ompd_get_thread_in_parallel(PyObject *self, PyObject *args);
1438PyObject *test_ompd_thread_handle_compare(PyObject *self, PyObject *args);
1439PyObject *test_ompd_get_thread_id(PyObject *self, PyObject *args);
1440PyObject *test_ompd_rel_thread_handle(PyObject *self, PyObject *args);
1441PyObject *test_ompd_get_enclosing_parallel_handle(PyObject *self,
                                                PyObject *args);
1443PyObject *test_ompd_parallel_handle_compare(PyObject *self, PyObject *args);
1444PyObject *test_ompd_rel_parallel_handle(PyObject *self, PyObject *args);
1445PyObject *test_ompd_initialize(PyObject *self, PyObject *noargs);
1446PyObject *test_ompd_get_api_version(PyObject *self, PyObject *noargs);
1447PyObject *test_ompd_get_version_string(PyObject *self, PyObject *noargs);
1448PyObject *test_ompd_finalize(PyObject *self, PyObject *noargs);
1449PyObject *test_ompd_process_initialize(PyObject *self, PyObject *noargs);
1450PyObject *test_ompd_device_initialize(PyObject *self, PyObject *noargs);
1451PyObject *test_ompd_rel_address_space_handle(PyObject *self, PyObject *noargs);
1452PyObject *test_ompd_get_omp_version(PyObject *self, PyObject *args);
1453PyObject *test_ompd_get_omp_version_string(PyObject *self, PyObject *args);
1454PyObject *test_ompd_get_curr_task_handle(PyObject *self, PyObject *args);
1455PyObject *test_ompd_get_task_parallel_handle(PyObject *self, PyObject *args);
1456PyObject *test_ompd_get_generating_task_handle(PyObject *self, PyObject *args);
1457PyObject *test_ompd_get_scheduling_task_handle(PyObject *self, PyObject *args);
1458PyObject *test_ompd_get_task_in_parallel(PyObject *self, PyObject *args);
1459PyObject *test_ompd_rel_task_handle(PyObject *self, PyObject *noargs);
1460PyObject *test_ompd_task_handle_compare(PyObject *self, PyObject *args);
1461PyObject *test_ompd_get_task_function(PyObject *self, PyObject *args);
1462PyObject *test_ompd_get_task_frame(PyObject *self, PyObject *args);
1463PyObject *test_ompd_get_state(PyObject *self, PyObject *args);
1464PyObject *test_ompd_get_display_control_vars(PyObject *self, PyObject *args);
1465PyObject *test_ompd_rel_display_control_vars(PyObject *self, PyObject *noargs);
1466PyObject *test_ompd_enumerate_icvs(PyObject *self, PyObject *noargs);
1467PyObject *test_ompd_get_icv_from_scope_with_addr_handle(PyObject *self,
                                                      PyObject *noargs);
1469PyObject *test_ompd_get_icv_from_scope_with_thread_handle(PyObject *self,
                                                        PyObject *noargs);
1471PyObject *test_ompd_get_icv_from_scope_with_parallel_handle(PyObject *self,
                                                          PyObject *noargs);
1473PyObject *test_ompd_get_icv_from_scope_with_task_handle(PyObject *self,
                                                      PyObject *noargs);
1475PyObject *test_ompd_get_icv_string_from_scope(PyObject *self, PyObject *noargs);
1476PyObject *test_ompd_get_tool_data(PyObject *self, PyObject *noargs);
1477PyObject *test_ompd_enumerate_states(PyObject *self, PyObject *noargs);
1478/**
* Binds Python function names to C functions.
*/
1481static PyMethodDef ompdModule_methods[] = {
  {"ompd_open", ompd_open, METH_VARARGS0x0001,
   "Execute dlopen, return OMPD version."},
  {"call_ompd_initialize", call_ompd_initialize, METH_NOARGS0x0004,
   "Initializes OMPD environment and callbacks."},
  {"call_ompd_rel_thread_handle", call_ompd_rel_thread_handle, METH_VARARGS0x0001,
   "Releases a thread handle."},
  {"get_thread_handle", get_thread_handle, METH_VARARGS0x0001,
   "Collects information on threads."},
  {"call_ompd_get_thread_in_parallel", call_ompd_get_thread_in_parallel,
   METH_VARARGS0x0001,
   "Obtains handle for a certain thread within parallel region."},
  {"call_ompd_get_curr_parallel_handle", call_ompd_get_curr_parallel_handle,
   METH_VARARGS0x0001,
   "Obtains a pointer to the parallel handle for the current parallel "
   "region."},
  {"call_ompd_get_enclosing_parallel_handle",
   call_ompd_get_enclosing_parallel_handle, METH_VARARGS0x0001,
   "Obtains a pointer to the parallel handle for the parallel region "
   "enclosing the parallel region specified."},
  {"call_ompd_get_task_parallel_handle", call_ompd_get_task_parallel_handle,
   METH_VARARGS0x0001,
   "Obtains a pointer to the parallel handle for the parallel region "
   "enclosing the task region specified."},
  {"call_ompd_rel_parallel_handle", call_ompd_rel_parallel_handle,
   METH_VARARGS0x0001, "Releases a parallel region handle."},
  {"call_ompd_get_curr_task_handle", call_ompd_get_curr_task_handle,
   METH_VARARGS0x0001,
   "Obtains a pointer to the task handle for the current task region "
   "associated with an OpenMP thread."},
  {"call_ompd_get_generating_task_handle",
   call_ompd_get_generating_task_handle, METH_VARARGS0x0001,
   "Obtains a pointer to the task handle for the task that was created when "
   "the task handle specified was encountered."},
  {"call_ompd_get_scheduling_task_handle",
   call_ompd_get_scheduling_task_handle, METH_VARARGS0x0001,
   "Obtains a pointer to the task handle for the task that scheduled the "
   "task specified."},
  {"call_ompd_get_task_in_parallel", call_ompd_get_task_in_parallel,
   METH_VARARGS0x0001,
   "Obtains the handle for implicit tasks associated with a parallel "
   "region."},
  {"call_ompd_rel_task_handle", call_ompd_rel_task_handle, METH_VARARGS0x0001,
   "Releases a task handle."},
  {"call_ompd_get_task_frame", call_ompd_get_task_frame, METH_VARARGS0x0001,
   "Returns a pointer to the enter and exit frame address and flag of the "
   "given task."},
  {"call_ompd_enumerate_icvs", call_ompd_enumerate_icvs, METH_VARARGS0x0001,
   "Saves ICVs in map."},
  {"call_ompd_get_icv_from_scope", call_ompd_get_icv_from_scope, METH_VARARGS0x0001,
   "Gets ICVs from scope."},
  {"call_ompd_enumerate_states", call_ompd_enumerate_states, METH_VARARGS0x0001,
   "Enumerates OMP states."},
  {"call_ompd_get_state", call_ompd_get_state, METH_VARARGS0x0001,
   "Returns state for given thread handle."},
  {"call_ompd_get_task_function", call_ompd_get_task_function, METH_VARARGS0x0001,
   "Returns point of code where task starts executing."},
  {"print_capsule", print_capsule, METH_VARARGS0x0001, "Print capsule content"},
  {"call_ompd_get_thread_id", call_ompd_get_thread_id, METH_VARARGS0x0001,
   "Maps an OMPD thread handle to a native thread."},
  {"call_ompd_get_tool_data", call_ompd_get_tool_data, METH_VARARGS0x0001,
   "Returns value and pointer of ompd_data_t for given scope and handle."},
  {"call_ompd_get_icv_string_from_scope", call_ompd_get_icv_string_from_scope,
   METH_VARARGS0x0001, "Gets ICV string representation from scope."},

  {"test_ompd_get_thread_handle", test_ompd_get_thread_handle, METH_VARARGS0x0001,
   "Test API ompd_get_thread_handle."},
  {"test_ompd_get_curr_parallel_handle", test_ompd_get_curr_parallel_handle,
   METH_VARARGS0x0001, "Test API test_ompd_get_curr_parallel_handle."},
  {"test_ompd_get_thread_in_parallel", test_ompd_get_thread_in_parallel,
   METH_VARARGS0x0001, "Test API ompd_get_thread_in_parallel."},
  {"test_ompd_thread_handle_compare", test_ompd_thread_handle_compare,
   METH_VARARGS0x0001, "Test API ompd_thread_handle_compare."},
  {"test_ompd_get_thread_id", test_ompd_get_thread_id, METH_VARARGS0x0001,
   "Test API ompd_get_thread_id."},
  {"test_ompd_rel_thread_handle", test_ompd_rel_thread_handle, METH_VARARGS0x0001,
   "Test API ompd_rel_thread_handle."},
  {"test_ompd_get_enclosing_parallel_handle",
   test_ompd_get_enclosing_parallel_handle, METH_VARARGS0x0001,
   "Test API ompd_get_enclosing_parallel_handle."},
  {"test_ompd_parallel_handle_compare", test_ompd_parallel_handle_compare,
   METH_VARARGS0x0001, "Test API test_ompd_parallel_handle_compare."},
  {"test_ompd_rel_parallel_handle", test_ompd_rel_parallel_handle,
   METH_VARARGS0x0001, "Test API ompd_rel_parallel_handle."},

  {"test_ompd_initialize", test_ompd_initialize, METH_VARARGS0x0001,
   "Test API ompd_initialize."},
  {"test_ompd_get_api_version", test_ompd_get_api_version, METH_VARARGS0x0001,
   "Test API ompd_get_api_version."},
  {"test_ompd_get_version_string", test_ompd_get_version_string, METH_VARARGS0x0001,
   "Test API ompd_get_version_string."},
  {"test_ompd_finalize", test_ompd_finalize, METH_VARARGS0x0001,
   "Test API ompd_finalize."},
  {"test_ompd_process_initialize", test_ompd_process_initialize, METH_VARARGS0x0001,
   "Test API ompd_process_initialize. "},
  {"test_ompd_device_initialize", test_ompd_device_initialize, METH_VARARGS0x0001,
   "Test API ompd_device_initialize."},
  {"test_ompd_rel_address_space_handle", test_ompd_rel_address_space_handle,
   METH_VARARGS0x0001, "Test API ompd_rel_address_space_handle."},
  {"test_ompd_get_omp_version", test_ompd_get_omp_version, METH_VARARGS0x0001,
   "Test API ompd_get_omp_version."},
  {"test_ompd_get_omp_version_string", test_ompd_get_omp_version_string,
   METH_VARARGS0x0001, "Test API ompd_get_omp_version_string."},

  {"test_ompd_get_curr_task_handle", test_ompd_get_curr_task_handle,
   METH_VARARGS0x0001, "Test API ompd_get_curr_task_handle."},
  {"test_ompd_get_task_parallel_handle", test_ompd_get_task_parallel_handle,
   METH_VARARGS0x0001, "Test API ompd_get_task_parallel_handle."},
  {"test_ompd_get_generating_task_handle",
   test_ompd_get_generating_task_handle, METH_VARARGS0x0001,
   "Test API ompd_get_generating_task_handle."},
  {"test_ompd_get_scheduling_task_handle",
   test_ompd_get_scheduling_task_handle, METH_VARARGS0x0001,
   "Test API ompd_get_scheduling_task_handle."},
  {"test_ompd_get_task_in_parallel", test_ompd_get_task_in_parallel,
   METH_VARARGS0x0001, "Test API ompd_get_task_in_parallel."},
  {"test_ompd_rel_task_handle", test_ompd_rel_task_handle, METH_VARARGS0x0001,
   "Test API ompd_rel_task_handle."},
  {"test_ompd_task_handle_compare", test_ompd_task_handle_compare,
   METH_VARARGS0x0001, "Test API ompd_task_handle_compare."},
  {"test_ompd_get_task_function", test_ompd_get_task_function, METH_VARARGS0x0001,
   "Test API ompd_get_task_function."},
  {"test_ompd_get_task_frame", test_ompd_get_task_frame, METH_VARARGS0x0001,
   "Test API ompd_get_task_frame."},
  {"test_ompd_get_state", test_ompd_get_state, METH_VARARGS0x0001,
   "Test API ompd_get_state."},
  {"test_ompd_get_display_control_vars", test_ompd_get_display_control_vars,
   METH_VARARGS0x0001, "Test API ompd_get_display_control_vars."},
  {"test_ompd_rel_display_control_vars", test_ompd_rel_display_control_vars,
   METH_VARARGS0x0001, "Test API ompd_rel_display_control_vars."},
  {"test_ompd_enumerate_icvs", test_ompd_enumerate_icvs, METH_VARARGS0x0001,
   "Test API ompd_enumerate_icvs."},
  {"test_ompd_get_icv_from_scope_with_addr_handle",
   test_ompd_get_icv_from_scope_with_addr_handle, METH_VARARGS0x0001,
   "Test API ompd_get_icv_from_scope with addr_handle."},
  {"test_ompd_get_icv_from_scope_with_thread_handle",
   test_ompd_get_icv_from_scope_with_thread_handle, METH_VARARGS0x0001,
   "Test API ompd_get_icv_from_scope with thread_handle."},
  {"test_ompd_get_icv_from_scope_with_parallel_handle",
   test_ompd_get_icv_from_scope_with_parallel_handle, METH_VARARGS0x0001,
   "Test API ompd_get_icv_from_scope with parallel_handle."},
  {"test_ompd_get_icv_from_scope_with_task_handle",
   test_ompd_get_icv_from_scope_with_task_handle, METH_VARARGS0x0001,
   "Test API ompd_get_icv_from_scope with task_handle."},
  {"test_ompd_get_icv_string_from_scope", test_ompd_get_icv_string_from_scope,
   METH_VARARGS0x0001, "Test API ompd_get_icv_string_from_scope."},
  {"test_ompd_get_tool_data", test_ompd_get_tool_data, METH_VARARGS0x0001,
   "Test API ompd_get_tool_data."},
  {"test_ompd_enumerate_states", test_ompd_enumerate_states, METH_VARARGS0x0001,
   "Test API ompd_enumerate_states."},
  {NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)}};

1633/**
* Lets Python initialize module.
*/
1636#if PY_MAJOR_VERSION3 >= 3
1637static struct PyModuleDef moduledef = {
  PyModuleDef_HEAD_INIT{ { 1, ((void*)0) }, ((void*)0), 0, ((void*)0), },
  "ompdModule",       /* m_name */
  "This is a module", /* m_doc */
  -1,                 /* m_size */
  ompdModule_methods, /* m_methods */
  NULL((void*)0),               /* m_reload */
  NULL((void*)0),               /* m_traverse */
  NULL((void*)0),               /* m_clear */
  NULL((void*)0),               /* m_free */
1647};
1648#endif
1649void PyInit_ompdModule(void) {
//	(void) Py_InitModule("ompdModule", ompdModule_methods);
PyModule_Create(&moduledef)PyModule_Create2(&moduledef, 1013);
1652}

←

/usr/include/python3.9/object.h

1#ifndef Py_OBJECT_H
2#define Py_OBJECT_H
3 
4#ifdef __cplusplus
5extern "C" {
6#endif
7 
8 
9/* Object and type object interface */
10 
11/*
12Objects are structures allocated on the heap.  Special rules apply to
13the use of objects to ensure they are properly garbage-collected.
14Objects are never allocated statically or on the stack; they must be
15accessed through special macros and functions only.  (Type objects are
16exceptions to the first rule; the standard types are represented by
17statically initialized type objects, although work on type/class unification
18for Python 2.2 made it possible to have heap-allocated type objects too).
19 
20An object has a 'reference count' that is increased or decreased when a
21pointer to the object is copied or deleted; when the reference count
22reaches zero there are no references to the object left and it can be
23removed from the heap.
24 
25An object has a 'type' that determines what it represents and what kind
26of data it contains.  An object's type is fixed when it is created.
27Types themselves are represented as objects; an object contains a
28pointer to the corresponding type object.  The type itself has a type
29pointer pointing to the object representing the type 'type', which
30contains a pointer to itself!.
31 
32Objects do not float around in memory; once allocated an object keeps
33the same size and address.  Objects that must hold variable-size data
34can contain pointers to variable-size parts of the object.  Not all
35objects of the same type have the same size; but the size cannot change
36after allocation.  (These restrictions are made so a reference to an
37object can be simply a pointer -- moving an object would require
38updating all the pointers, and changing an object's size would require
39moving it if there was another object right next to it.)
40 
41Objects are always accessed through pointers of the type 'PyObject *'.
42The type 'PyObject' is a structure that only contains the reference count
43and the type pointer.  The actual memory allocated for an object
44contains other data that can only be accessed after casting the pointer
45to a pointer to a longer structure type.  This longer type must start
46with the reference count and type fields; the macro PyObject_HEAD should be
47used for this (to accommodate for future changes).  The implementation
48of a particular object type can cast the object pointer to the proper
49type and back.
50 
51A standard interface exists for objects that contain an array of items
52whose size is determined when the object is allocated.
53*/
54 
55/* Py_DEBUG implies Py_REF_DEBUG. */
56#if defined(Py_DEBUG) && !defined(Py_REF_DEBUG)
57#define Py_REF_DEBUG
58#endif
59 
60#if defined(Py_LIMITED_API) && defined(Py_REF_DEBUG)
61#error Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, and Py_REF_DEBUG
62#endif
63 
64/* PyTypeObject structure is defined in cpython/object.h.
65   In Py_LIMITED_API, PyTypeObject is an opaque structure. */
66typedef struct _typeobject PyTypeObject;
67 
68#ifdef Py_TRACE_REFS
69/* Define pointers to support a doubly-linked list of all live heap objects. */
70#define _PyObject_HEAD_EXTRA            \
71    struct _object *_ob_next;           \
72    struct _object *_ob_prev;
73 
74#define _PyObject_EXTRA_INIT 0, 0,
75 
76#else
77#define _PyObject_HEAD_EXTRA
78#define _PyObject_EXTRA_INIT
79#endif
80 
81/* PyObject_HEAD defines the initial segment of every PyObject. */
82#define PyObject_HEADPyObject ob_base;                   PyObject ob_base;
83 
84#define PyObject_HEAD_INIT(type){ 1, type },        \
85    { _PyObject_EXTRA_INIT              \
86    1, type },
87 
88#define PyVarObject_HEAD_INIT(type, size){ { 1, type }, size },       \
89    { PyObject_HEAD_INIT(type){ 1, type }, size },
90 
91/* PyObject_VAR_HEAD defines the initial segment of all variable-size
92 * container objects.  These end with a declaration of an array with 1
93 * element, but enough space is malloc'ed so that the array actually
94 * has room for ob_size elements.  Note that ob_size is an element count,
95 * not necessarily a byte count.
96 */
97#define PyObject_VAR_HEADPyVarObject ob_base;      PyVarObject ob_base;
98#define Py_INVALID_SIZE(Py_ssize_t)-1 (Py_ssize_t)-1
99 
100/* Nothing is actually declared to be a PyObject, but every pointer to
101 * a Python object can be cast to a PyObject*.  This is inheritance built
102 * by hand.  Similarly every pointer to a variable-size Python object can,
103 * in addition, be cast to PyVarObject*.
104 */
105typedef struct _object {
106    _PyObject_HEAD_EXTRA
107    Py_ssize_t ob_refcnt;
108    PyTypeObject *ob_type;
109} PyObject;
110 
111/* Cast argument to PyObject* type. */
112#define _PyObject_CAST(op)((PyObject*)(op)) ((PyObject*)(op))
113#define _PyObject_CAST_CONST(op)((const PyObject*)(op)) ((const PyObject*)(op))
114 
115typedef struct {
116    PyObject ob_base;
117    Py_ssize_t ob_size; /* Number of items in variable part */
118} PyVarObject;
119 
120/* Cast argument to PyVarObject* type. */
121#define _PyVarObject_CAST(op)((PyVarObject*)(op)) ((PyVarObject*)(op))
122 
123#define Py_REFCNT(ob)(((PyObject*)(ob))->ob_refcnt)           (_PyObject_CAST(ob)((PyObject*)(ob))->ob_refcnt)
124#define Py_TYPE(ob)(((PyObject*)(ob))->ob_type)             (_PyObject_CAST(ob)((PyObject*)(ob))->ob_type)
125#define Py_SIZE(ob)(((PyVarObject*)(ob))->ob_size)             (_PyVarObject_CAST(ob)((PyVarObject*)(ob))->ob_size)
126 
127static inline int _Py_IS_TYPE(const PyObject *ob, const PyTypeObject *type) {
128    return ob->ob_type == type;
9
←
Access to field 'ob_type' results in a dereference of a null pointer (loaded from variable 'ob')
129}
130#define Py_IS_TYPE(ob, type)_Py_IS_TYPE(((const PyObject*)(ob)), type) _Py_IS_TYPE(_PyObject_CAST_CONST(ob)((const PyObject*)(ob)), type)
131 
132static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {
133    ob->ob_refcnt = refcnt;
134}
135#define Py_SET_REFCNT(ob, refcnt)_Py_SET_REFCNT(((PyObject*)(ob)), refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob)((PyObject*)(ob)), refcnt)
136 
137static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) {
138    ob->ob_type = type;
139}
140#define Py_SET_TYPE(ob, type)_Py_SET_TYPE(((PyObject*)(ob)), type) _Py_SET_TYPE(_PyObject_CAST(ob)((PyObject*)(ob)), type)
141 
142static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) {
143    ob->ob_size = size;
144}
145#define Py_SET_SIZE(ob, size)_Py_SET_SIZE(((PyVarObject*)(ob)), size) _Py_SET_SIZE(_PyVarObject_CAST(ob)((PyVarObject*)(ob)), size)
146 
147 
148/*
149Type objects contain a string containing the type name (to help somewhat
150in debugging), the allocation parameters (see PyObject_New() and
151PyObject_NewVar()),
152and methods for accessing objects of the type.  Methods are optional, a
153nil pointer meaning that particular kind of access is not available for
154this type.  The Py_DECREF() macro uses the tp_dealloc method without
155checking for a nil pointer; it should always be implemented except if
156the implementation can guarantee that the reference count will never
157reach zero (e.g., for statically allocated type objects).
158 
159NB: the methods for certain type groups are now contained in separate
160method blocks.
161*/
162 
163typedef PyObject * (*unaryfunc)(PyObject *);
164typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
165typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
166typedef int (*inquiry)(PyObject *);
167typedef Py_ssize_t (*lenfunc)(PyObject *);
168typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
169typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
170typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
171typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
172typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
173 
174typedef int (*objobjproc)(PyObject *, PyObject *);
175typedef int (*visitproc)(PyObject *, void *);
176typedef int (*traverseproc)(PyObject *, visitproc, void *);
177 
178 
179typedef void (*freefunc)(void *);
180typedef void (*destructor)(PyObject *);
181typedef PyObject *(*getattrfunc)(PyObject *, char *);
182typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
183typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
184typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
185typedef PyObject *(*reprfunc)(PyObject *);
186typedef Py_hash_t (*hashfunc)(PyObject *);
187typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
188typedef PyObject *(*getiterfunc) (PyObject *);
189typedef PyObject *(*iternextfunc) (PyObject *);
190typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
191typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
192typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
193typedef PyObject *(*newfunc)(PyTypeObject *, PyObject *, PyObject *);
194typedef PyObject *(*allocfunc)(PyTypeObject *, Py_ssize_t);
195 
196typedef struct{
197    int slot;    /* slot id, see below */
198    void *pfunc; /* function pointer */
199} PyType_Slot;
200 
201typedef struct{
202    const char* name;
203    int basicsize;
204    int itemsize;
205    unsigned int flags;
206    PyType_Slot *slots; /* terminated by slot==0. */
207} PyType_Spec;
208 
209PyAPI_FUNC(PyObject*)__attribute__ ((visibility ("default"))) PyObject* PyType_FromSpec(PyType_Spec*);
210#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
211PyAPI_FUNC(PyObject*)__attribute__ ((visibility ("default"))) PyObject* PyType_FromSpecWithBases(PyType_Spec*, PyObject*);
212#endif
213#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
214PyAPI_FUNC(void*)__attribute__ ((visibility ("default"))) void* PyType_GetSlot(PyTypeObject*, int);
215#endif
216#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
217PyAPI_FUNC(PyObject*)__attribute__ ((visibility ("default"))) PyObject* PyType_FromModuleAndSpec(PyObject *, PyType_Spec *, PyObject *);
218PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyType_GetModule(struct _typeobject *);
219PyAPI_FUNC(void *)__attribute__ ((visibility ("default"))) void * PyType_GetModuleState(struct _typeobject *);
220#endif
221 
222/* Generic type check */
223PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
224#define PyObject_TypeCheck(ob, tp)(_Py_IS_TYPE(((const PyObject*)(ob)), tp) || PyType_IsSubtype
((((PyObject*)(ob))->ob_type), (tp))) \
225    (Py_IS_TYPE(ob, tp)_Py_IS_TYPE(((const PyObject*)(ob)), tp) || PyType_IsSubtype(Py_TYPE(ob)(((PyObject*)(ob))->ob_type), (tp)))
226 
227PyAPI_DATA(PyTypeObject)extern __attribute__ ((visibility ("default"))) PyTypeObject PyType_Type; /* built-in 'type' */
228PyAPI_DATA(PyTypeObject)extern __attribute__ ((visibility ("default"))) PyTypeObject PyBaseObject_Type; /* built-in 'object' */
229PyAPI_DATA(PyTypeObject)extern __attribute__ ((visibility ("default"))) PyTypeObject PySuper_Type; /* built-in 'super' */
230 
231PyAPI_FUNC(unsigned long)__attribute__ ((visibility ("default"))) unsigned long PyType_GetFlags(PyTypeObject*);
232 
233PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyType_Ready(PyTypeObject *);
234PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
235PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyType_GenericNew(PyTypeObject *,
236                                               PyObject *, PyObject *);
237PyAPI_FUNC(unsigned int)__attribute__ ((visibility ("default"))) unsigned int PyType_ClearCache(void);
238PyAPI_FUNC(void)__attribute__ ((visibility ("default"))) void PyType_Modified(PyTypeObject *);
239 
240/* Generic operations on objects */
241PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_Repr(PyObject *);
242PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_Str(PyObject *);
243PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_ASCII(PyObject *);
244PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_Bytes(PyObject *);
245PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_RichCompare(PyObject *, PyObject *, int);
246PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_RichCompareBool(PyObject *, PyObject *, int);
247PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_GetAttrString(PyObject *, const char *);
248PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_SetAttrString(PyObject *, const char *, PyObject *);
249PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_HasAttrString(PyObject *, const char *);
250PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_GetAttr(PyObject *, PyObject *);
251PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
252PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_HasAttr(PyObject *, PyObject *);
253PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_SelfIter(PyObject *);
254PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_GenericGetAttr(PyObject *, PyObject *);
255PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_GenericSetAttr(PyObject *, PyObject *, PyObject *);
256#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
257PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_GenericSetDict(PyObject *, PyObject *, void *);
258#endif
259PyAPI_FUNC(Py_hash_t)__attribute__ ((visibility ("default"))) Py_hash_t PyObject_Hash(PyObject *);
260PyAPI_FUNC(Py_hash_t)__attribute__ ((visibility ("default"))) Py_hash_t PyObject_HashNotImplemented(PyObject *);
261PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_IsTrue(PyObject *);
262PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyObject_Not(PyObject *);
263PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int PyCallable_Check(PyObject *);
264PyAPI_FUNC(void)__attribute__ ((visibility ("default"))) void PyObject_ClearWeakRefs(PyObject *);
265 
266/* PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a
267   list of strings.  PyObject_Dir(NULL) is like builtins.dir(),
268   returning the names of the current locals.  In this case, if there are
269   no current locals, NULL is returned, and PyErr_Occurred() is false.
270*/
271PyAPI_FUNC(PyObject *)__attribute__ ((visibility ("default"))) PyObject * PyObject_Dir(PyObject *);
272 
273 
274/* Helpers for printing recursive container types */
275PyAPI_FUNC(int)__attribute__ ((visibility ("default"))) int Py_ReprEnter(PyObject *);
276PyAPI_FUNC(void)__attribute__ ((visibility ("default"))) void Py_ReprLeave(PyObject *);
277 
278/* Flag bits for printing: */
279#define Py_PRINT_RAW1    1       /* No string quotes etc. */
280 
281/*
282Type flags (tp_flags)
283 
284These flags are used to change expected features and behavior for a
285particular type.
286 
287Arbitration of the flag bit positions will need to be coordinated among
288all extension writers who publicly release their extensions (this will
289be fewer than you might expect!).
290 
291Most flags were removed as of Python 3.0 to make room for new flags.  (Some
292flags are not for backwards compatibility but to indicate the presence of an
293optional feature; these flags remain of course.)
294 
295Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value.
296 
297Code can use PyType_HasFeature(type_ob, flag_value) to test whether the
298given type object has a specified feature.
299*/
300 
301/* Set if the type object is dynamically allocated */
302#define Py_TPFLAGS_HEAPTYPE(1UL << 9) (1UL << 9)
303 
304/* Set if the type allows subclassing */
305#define Py_TPFLAGS_BASETYPE(1UL << 10) (1UL << 10)
306 
307/* Set if the type implements the vectorcall protocol (PEP 590) */
308#ifndef Py_LIMITED_API
309#define Py_TPFLAGS_HAVE_VECTORCALL(1UL << 11) (1UL << 11)
310// Backwards compatibility alias for API that was provisional in Python 3.8
311#define _Py_TPFLAGS_HAVE_VECTORCALL(1UL << 11) Py_TPFLAGS_HAVE_VECTORCALL(1UL << 11)
312#endif
313 
314/* Set if the type is 'ready' -- fully initialized */
315#define Py_TPFLAGS_READY(1UL << 12) (1UL << 12)
316 
317/* Set while the type is being 'readied', to prevent recursive ready calls */
318#define Py_TPFLAGS_READYING(1UL << 13) (1UL << 13)
319 
320/* Objects support garbage collection (see objimpl.h) */
321#define Py_TPFLAGS_HAVE_GC(1UL << 14) (1UL << 14)
322 
323/* These two bits are preserved for Stackless Python, next after this is 17 */
324#ifdef STACKLESS
325#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION0 (3UL << 15)
326#else
327#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION0 0
328#endif
329 
330/* Objects behave like an unbound method */
331#define Py_TPFLAGS_METHOD_DESCRIPTOR(1UL << 17) (1UL << 17)
332 
333/* Objects support type attribute cache */
334#define Py_TPFLAGS_HAVE_VERSION_TAG(1UL << 18)   (1UL << 18)
335#define Py_TPFLAGS_VALID_VERSION_TAG(1UL << 19)  (1UL << 19)
336 
337/* Type is abstract and cannot be instantiated */
338#define Py_TPFLAGS_IS_ABSTRACT(1UL << 20) (1UL << 20)
339 
340/* These flags are used to determine if a type is a subclass. */
341#define Py_TPFLAGS_LONG_SUBCLASS(1UL << 24)        (1UL << 24)
342#define Py_TPFLAGS_LIST_SUBCLASS(1UL << 25)        (1UL << 25)
343#define Py_TPFLAGS_TUPLE_SUBCLASS(1UL << 26)       (1UL << 26)
344#define Py_TPFLAGS_BYTES_SUBCLASS(1UL << 27)       (1UL << 27)
345#define Py_TPFLAGS_UNICODE_SUBCLASS(1UL << 28)     (1UL << 28)
346#define Py_TPFLAGS_DICT_SUBCLASS(1UL << 29)        (1UL << 29)
347#define Py_TPFLAGS_BASE_EXC_SUBCLASS(1UL << 30)    (1UL << 30)
348#define Py_TPFLAGS_TYPE_SUBCLASS(1UL << 31)        (1UL << 31)
349 
350#define Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0)  ( \
351                 Py_TPFLAGS_HAVE_STACKLESS_EXTENSION0 | \
352                 Py_TPFLAGS_HAVE_VERSION_TAG(1UL << 18) | \
353                0)
354 
355/* NOTE: The following flags reuse lower bits (removed as part of the
356 * Python 3.0 transition). */
357 
358/* The following flag is kept for compatibility. Starting with 3.8,
359 * binary compatibility of C extensions across feature releases of
360 * Python is not supported anymore, except when using the stable ABI.
361 */
362 
363/* Type structure has tp_finalize member (3.4) */
364#define Py_TPFLAGS_HAVE_FINALIZE(1UL << 0) (1UL << 0)
365 
366 
367/*
368The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement
369reference counts.  Py_DECREF calls the object's deallocator function when
370the refcount falls to 0; for
371objects that don't contain references to other objects or heap memory
372this can be the standard function free().  Both macros can be used
373wherever a void expression is allowed.  The argument must not be a
374NULL pointer.  If it may be NULL, use Py_XINCREF/Py_XDECREF instead.
375The macro _Py_NewReference(op) initialize reference counts to 1, and
376in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional
377bookkeeping appropriate to the special build.
378 
379We assume that the reference count field can never overflow; this can
380be proven when the size of the field is the same as the pointer size, so
381we ignore the possibility.  Provided a C int is at least 32 bits (which
382is implicitly assumed in many parts of this code), that's enough for
383about 2**31 references to an object.
384 
385XXX The following became out of date in Python 2.2, but I'm not sure
386XXX what the full truth is now.  Certainly, heap-allocated type objects
387XXX can and should be deallocated.
388Type objects should never be deallocated; the type pointer in an object
389is not considered to be a reference to the type object, to save
390complications in the deallocation function.  (This is actually a
391decision that's up to the implementer of each new type so if you want,
392you can count such references to the type object.)
393*/
394 
395#ifdef Py_REF_DEBUG
396PyAPI_DATA(Py_ssize_t)extern __attribute__ ((visibility ("default"))) Py_ssize_t _Py_RefTotal;
397PyAPI_FUNC(void)__attribute__ ((visibility ("default"))) void _Py_NegativeRefcount(const char *filename, int lineno,
398                                      PyObject *op);
399#endif /* Py_REF_DEBUG */
400 
401PyAPI_FUNC(void)__attribute__ ((visibility ("default"))) void _Py_Dealloc(PyObject *);
402 
403static inline void _Py_INCREF(PyObject *op)
404{
405#ifdef Py_REF_DEBUG
406    _Py_RefTotal++;
407#endif
408    op->ob_refcnt++;
409}
410 
411#define Py_INCREF(op)_Py_INCREF(((PyObject*)(op))) _Py_INCREF(_PyObject_CAST(op)((PyObject*)(op)))
412 
413static inline void _Py_DECREF(
414#ifdef Py_REF_DEBUG
415    const char *filename, int lineno,
416#endif
417    PyObject *op)
418{
419#ifdef Py_REF_DEBUG
420    _Py_RefTotal--;
421#endif
422    if (--op->ob_refcnt != 0) {
423#ifdef Py_REF_DEBUG
424        if (op->ob_refcnt < 0) {
425            _Py_NegativeRefcount(filename, lineno, op);
426        }
427#endif
428    }
429    else {
430        _Py_Dealloc(op);
431    }
432}
433 
434#ifdef Py_REF_DEBUG
435#  define Py_DECREF(op)_Py_DECREF(((PyObject*)(op))) _Py_DECREF(__FILE__"/usr/include/python3.9/object.h", __LINE__435, _PyObject_CAST(op)((PyObject*)(op)))
436#else
437#  define Py_DECREF(op)_Py_DECREF(((PyObject*)(op))) _Py_DECREF(_PyObject_CAST(op)((PyObject*)(op)))
438#endif
439 
440 
441/* Safely decref `op` and set `op` to NULL, especially useful in tp_clear
442 * and tp_dealloc implementations.
443 *
444 * Note that "the obvious" code can be deadly:
445 *
446 *     Py_XDECREF(op);
447 *     op = NULL;
448 *
449 * Typically, `op` is something like self->containee, and `self` is done
450 * using its `containee` member.  In the code sequence above, suppose
451 * `containee` is non-NULL with a refcount of 1.  Its refcount falls to
452 * 0 on the first line, which can trigger an arbitrary amount of code,
453 * possibly including finalizers (like __del__ methods or weakref callbacks)
454 * coded in Python, which in turn can release the GIL and allow other threads
455 * to run, etc.  Such code may even invoke methods of `self` again, or cause
456 * cyclic gc to trigger, but-- oops! --self->containee still points to the
457 * object being torn down, and it may be in an insane state while being torn
458 * down.  This has in fact been a rich historic source of miserable (rare &
459 * hard-to-diagnose) segfaulting (and other) bugs.
460 *
461 * The safe way is:
462 *
463 *      Py_CLEAR(op);
464 *
465 * That arranges to set `op` to NULL _before_ decref'ing, so that any code
466 * triggered as a side-effect of `op` getting torn down no longer believes
467 * `op` points to a valid object.
468 *
469 * There are cases where it's safe to use the naive code, but they're brittle.
470 * For example, if `op` points to a Python integer, you know that destroying
471 * one of those can't cause problems -- but in part that relies on that
472 * Python integers aren't currently weakly referencable.  Best practice is
473 * to use Py_CLEAR() even if you can't think of a reason for why you need to.
474 */
475#define Py_CLEAR(op)do { PyObject *_py_tmp = ((PyObject*)(op)); if (_py_tmp != ((
void*)0)) { (op) = ((void*)0); _Py_DECREF(((PyObject*)(_py_tmp
))); } } while (0)                            \
476    do {                                        \
477        PyObject *_py_tmp = _PyObject_CAST(op)((PyObject*)(op)); \
478        if (_py_tmp != NULL((void*)0)) {                  \
479            (op) = NULL((void*)0);                        \
480            Py_DECREF(_py_tmp)_Py_DECREF(((PyObject*)(_py_tmp)));                 \
481        }                                       \
482    } while (0)
483 
484/* Function to use in case the object pointer can be NULL: */
485static inline void _Py_XINCREF(PyObject *op)
486{
487    if (op != NULL((void*)0)) {
488        Py_INCREF(op)_Py_INCREF(((PyObject*)(op)));
489    }
490}
491 
492#define Py_XINCREF(op)_Py_XINCREF(((PyObject*)(op))) _Py_XINCREF(_PyObject_CAST(op)((PyObject*)(op)))
493 
494static inline void _Py_XDECREF(PyObject *op)
495{
496    if (op != NULL((void*)0)) {
497        Py_DECREF(op)_Py_DECREF(((PyObject*)(op)));
498    }
499}
500 
501#define Py_XDECREF(op)_Py_XDECREF(((PyObject*)(op))) _Py_XDECREF(_PyObject_CAST(op)((PyObject*)(op)))
502 
503/*
504These are provided as conveniences to Python runtime embedders, so that
505they can have object code that is not dependent on Python compilation flags.
506*/
507PyAPI_FUNC(void)__attribute__ ((visibility ("default"))) void Py_IncRef(PyObject *);
508PyAPI_FUNC(void)__attribute__ ((visibility ("default"))) void Py_DecRef(PyObject *);
509 
510/*
511_Py_NoneStruct is an object of undefined type which can be used in contexts
512where NULL (nil) is not suitable (since NULL often means 'error').
513 
514Don't forget to apply Py_INCREF() when returning this value!!!
515*/
516PyAPI_DATA(PyObject)extern __attribute__ ((visibility ("default"))) PyObject _Py_NoneStruct; /* Don't use this directly */
517#define Py_None(&_Py_NoneStruct) (&_Py_NoneStruct)
518 
519/* Macro for returning Py_None from a function */
520#define Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct) return Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), Py_None(&_Py_NoneStruct)
521 
522/*
523Py_NotImplemented is a singleton used to signal that an operation is
524not implemented for a given type combination.
525*/
526PyAPI_DATA(PyObject)extern __attribute__ ((visibility ("default"))) PyObject _Py_NotImplementedStruct; /* Don't use this directly */
527#define Py_NotImplemented(&_Py_NotImplementedStruct) (&_Py_NotImplementedStruct)
528 
529/* Macro for returning Py_NotImplemented from a function */
530#define Py_RETURN_NOTIMPLEMENTEDreturn _Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct
)))), (&_Py_NotImplementedStruct) \
531    return Py_INCREF(Py_NotImplemented)_Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct)))), Py_NotImplemented(&_Py_NotImplementedStruct)
532 
533/* Rich comparison opcodes */
534#define Py_LT0 0
535#define Py_LE1 1
536#define Py_EQ2 2
537#define Py_NE3 3
538#define Py_GT4 4
539#define Py_GE5 5
540 
541/*
542 * Macro for implementing rich comparisons
543 *
544 * Needs to be a macro because any C-comparable type can be used.
545 */
546#define Py_RETURN_RICHCOMPARE(val1, val2, op)do { switch (op) { case 2: if ((val1) == (val2)) return _Py_INCREF
(((PyObject*)(((PyObject *) &_Py_TrueStruct)))), ((PyObject
 *) &_Py_TrueStruct); return _Py_INCREF(((PyObject*)(((PyObject
 *) &_Py_FalseStruct)))), ((PyObject *) &_Py_FalseStruct
); case 3: if ((val1) != (val2)) return _Py_INCREF(((PyObject
*)(((PyObject *) &_Py_TrueStruct)))), ((PyObject *) &
_Py_TrueStruct); return _Py_INCREF(((PyObject*)(((PyObject *)
 &_Py_FalseStruct)))), ((PyObject *) &_Py_FalseStruct
); case 0: if ((val1) < (val2)) return _Py_INCREF(((PyObject
*)(((PyObject *) &_Py_TrueStruct)))), ((PyObject *) &
_Py_TrueStruct); return _Py_INCREF(((PyObject*)(((PyObject *)
 &_Py_FalseStruct)))), ((PyObject *) &_Py_FalseStruct
); case 4: if ((val1) > (val2)) return _Py_INCREF(((PyObject
*)(((PyObject *) &_Py_TrueStruct)))), ((PyObject *) &
_Py_TrueStruct); return _Py_INCREF(((PyObject*)(((PyObject *)
 &_Py_FalseStruct)))), ((PyObject *) &_Py_FalseStruct
); case 1: if ((val1) <= (val2)) return _Py_INCREF(((PyObject
*)(((PyObject *) &_Py_TrueStruct)))), ((PyObject *) &
_Py_TrueStruct); return _Py_INCREF(((PyObject*)(((PyObject *)
 &_Py_FalseStruct)))), ((PyObject *) &_Py_FalseStruct
); case 5: if ((val1) >= (val2)) return _Py_INCREF(((PyObject
*)(((PyObject *) &_Py_TrueStruct)))), ((PyObject *) &
_Py_TrueStruct); return _Py_INCREF(((PyObject*)(((PyObject *)
 &_Py_FalseStruct)))), ((PyObject *) &_Py_FalseStruct
); default: __builtin_unreachable(); } } while (0)                               \
547    do {                                                                    \
548        switch (op) {                                                       \
549        case Py_EQ2: if ((val1) == (val2)) Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct); Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);  \
550        case Py_NE3: if ((val1) != (val2)) Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct); Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);  \
551        case Py_LT0: if ((val1) < (val2)) Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct); Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);   \
552        case Py_GT4: if ((val1) > (val2)) Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct); Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);   \
553        case Py_LE1: if ((val1) <= (val2)) Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct); Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);  \
554        case Py_GE5: if ((val1) >= (val2)) Py_RETURN_TRUEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_TrueStruct
)))), ((PyObject *) &_Py_TrueStruct); Py_RETURN_FALSEreturn _Py_INCREF(((PyObject*)(((PyObject *) &_Py_FalseStruct
)))), ((PyObject *) &_Py_FalseStruct);  \
555        default:                                                            \
556            Py_UNREACHABLE()__builtin_unreachable();                                               \
557        }                                                                   \
558    } while (0)
559 
560 
561/*
562More conventions
563================
564 
565Argument Checking
566-----------------
567 
568Functions that take objects as arguments normally don't check for nil
569arguments, but they do check the type of the argument, and return an
570error if the function doesn't apply to the type.
571 
572Failure Modes
573-------------
574 
575Functions may fail for a variety of reasons, including running out of
576memory.  This is communicated to the caller in two ways: an error string
577is set (see errors.h), and the function result differs: functions that
578normally return a pointer return NULL for failure, functions returning
579an integer return -1 (which could be a legal return value too!), and
580other functions return 0 for success and -1 for failure.
581Callers should always check for errors before using the result.  If
582an error was set, the caller must either explicitly clear it, or pass
583the error on to its caller.
584 
585Reference Counts
586----------------
587 
588It takes a while to get used to the proper usage of reference counts.
589 
590Functions that create an object set the reference count to 1; such new
591objects must be stored somewhere or destroyed again with Py_DECREF().
592Some functions that 'store' objects, such as PyTuple_SetItem() and
593PyList_SetItem(),
594don't increment the reference count of the object, since the most
595frequent use is to store a fresh object.  Functions that 'retrieve'
596objects, such as PyTuple_GetItem() and PyDict_GetItemString(), also
597don't increment
598the reference count, since most frequently the object is only looked at
599quickly.  Thus, to retrieve an object and store it again, the caller
600must call Py_INCREF() explicitly.
601 
602NOTE: functions that 'consume' a reference count, like
603PyList_SetItem(), consume the reference even if the object wasn't
604successfully stored, to simplify error handling.
605 
606It seems attractive to make other functions that take an object as
607argument consume a reference count; however, this may quickly get
608confusing (even the current practice is already confusing).  Consider
609it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at
610times.
611*/
612 
613#ifndef Py_LIMITED_API
614#  define Py_CPYTHON_OBJECT_H
615#  include  "cpython/object.h"
616#  undef Py_CPYTHON_OBJECT_H
617#endif
618 
619 
620static inline int
621PyType_HasFeature(PyTypeObject *type, unsigned long feature)
622{
623    unsigned long flags;
624#ifdef Py_LIMITED_API
625    // PyTypeObject is opaque in the limited C API
626    flags = PyType_GetFlags(type);
627#else
628    flags = type->tp_flags;
629#endif
630    return ((flags & feature) != 0);
631}
632 
633#define PyType_FastSubclass(type, flag)PyType_HasFeature(type, flag) PyType_HasFeature(type, flag)
634 
635static inline int _PyType_Check(PyObject *op) {
636    return PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)PyType_HasFeature((((PyObject*)(op))->ob_type), (1UL <<
 31));
637}
638#define PyType_Check(op)_PyType_Check(((PyObject*)(op))) _PyType_Check(_PyObject_CAST(op)((PyObject*)(op)))
639 
640static inline int _PyType_CheckExact(PyObject *op) {
641    return Py_IS_TYPE(op, &PyType_Type)_Py_IS_TYPE(((const PyObject*)(op)), &PyType_Type);
642}
643#define PyType_CheckExact(op)_PyType_CheckExact(((PyObject*)(op))) _PyType_CheckExact(_PyObject_CAST(op)((PyObject*)(op)))
644 
645#ifdef __cplusplus
646}
647#endif
648#endif /* !Py_OBJECT_H */