1#include "kmp_config.h"
2
3#if USE_DEBUGGER
4/*
5 * kmp_debugger.cpp -- debugger support.
6 */
7
8//===----------------------------------------------------------------------===//
9//
10// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
11// See https://llvm.org/LICENSE.txt for license information.
12// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
13//
14//===----------------------------------------------------------------------===//
15
16#include "kmp.h"
17#include "kmp_lock.h"
18#include "kmp_omp.h"
19#include "kmp_str.h"
20
21// NOTE: All variable names are known to the debugger, do not change!
22
23#ifdef __cplusplus
24extern "C" {
25extern kmp_omp_struct_info_t __kmp_omp_debug_struct_info;
26} // extern "C"
27#endif // __cplusplus
28
29int __kmp_debugging = FALSE; // Boolean whether currently debugging OpenMP RTL.
30
31#define offset_and_size_of(structure, field)                                   \
32  { offsetof(structure, field), sizeof(((structure *)NULL)->field) }
33
34#define offset_and_size_not_available                                          \
35  { -1, -1 }
36
37#define addr_and_size_of(var)                                                  \
38  { (kmp_uint64)(&var), sizeof(var) }
39
40#define nthr_buffer_size 1024
41static kmp_int32 kmp_omp_nthr_info_buffer[nthr_buffer_size] = {
42    nthr_buffer_size * sizeof(kmp_int32)};
43
44/* TODO: Check punctuation for various platforms here */
45static char func_microtask[] = "__kmp_invoke_microtask";
46static char func_fork[] = "__kmpc_fork_call";
47static char func_fork_teams[] = "__kmpc_fork_teams";
48
49// Various info about runtime structures: addresses, field offsets, sizes, etc.
50kmp_omp_struct_info_t __kmp_omp_debug_struct_info = {
51
52    /* Change this only if you make a fundamental data structure change here */
53    KMP_OMP_VERSION,
54
55    /* sanity check.  Only should be checked if versions are identical
56     * This is also used for backward compatibility to get the runtime
57     * structure size if it the runtime is older than the interface */
58    sizeof(kmp_omp_struct_info_t),
59
60    /* OpenMP RTL version info. */
61    addr_and_size_of(__kmp_version_major),
62    addr_and_size_of(__kmp_version_minor),
63    addr_and_size_of(__kmp_version_build),
64    addr_and_size_of(__kmp_openmp_version),
65    {(kmp_uint64)(__kmp_copyright) + KMP_VERSION_MAGIC_LEN,
66     0}, // Skip magic prefix.
67
68    /* Various globals. */
69    addr_and_size_of(__kmp_threads),
70    addr_and_size_of(__kmp_root),
71    addr_and_size_of(__kmp_threads_capacity),
72#if KMP_USE_MONITOR
73    addr_and_size_of(__kmp_monitor),
74#endif
75#if !KMP_USE_DYNAMIC_LOCK
76    addr_and_size_of(__kmp_user_lock_table),
77#endif
78    addr_and_size_of(func_microtask),
79    addr_and_size_of(func_fork),
80    addr_and_size_of(func_fork_teams),
81    addr_and_size_of(__kmp_team_counter),
82    addr_and_size_of(__kmp_task_counter),
83    addr_and_size_of(kmp_omp_nthr_info_buffer),
84    sizeof(void *),
85    OMP_LOCK_T_SIZE < sizeof(void *),
86    bs_last_barrier,
87    INITIAL_TASK_DEQUE_SIZE,
88
89    // thread structure information
90    sizeof(kmp_base_info_t),
91    offset_and_size_of(kmp_base_info_t, th_info),
92    offset_and_size_of(kmp_base_info_t, th_team),
93    offset_and_size_of(kmp_base_info_t, th_root),
94    offset_and_size_of(kmp_base_info_t, th_serial_team),
95    offset_and_size_of(kmp_base_info_t, th_ident),
96    offset_and_size_of(kmp_base_info_t, th_spin_here),
97    offset_and_size_of(kmp_base_info_t, th_next_waiting),
98    offset_and_size_of(kmp_base_info_t, th_task_team),
99    offset_and_size_of(kmp_base_info_t, th_current_task),
100    offset_and_size_of(kmp_base_info_t, th_task_state),
101    offset_and_size_of(kmp_base_info_t, th_bar),
102    offset_and_size_of(kmp_bstate_t, b_worker_arrived),
103
104    // teams information
105    offset_and_size_of(kmp_base_info_t, th_teams_microtask),
106    offset_and_size_of(kmp_base_info_t, th_teams_level),
107    offset_and_size_of(kmp_teams_size_t, nteams),
108    offset_and_size_of(kmp_teams_size_t, nth),
109
110    // kmp_desc structure (for info field above)
111    sizeof(kmp_desc_base_t),
112    offset_and_size_of(kmp_desc_base_t, ds_tid),
113    offset_and_size_of(kmp_desc_base_t, ds_gtid),
114// On Windows* OS, ds_thread contains a thread /handle/, which is not usable,
115// while thread /id/ is in ds_thread_id.
116#if KMP_OS_WINDOWS
117    offset_and_size_of(kmp_desc_base_t, ds_thread_id),
118#else
119    offset_and_size_of(kmp_desc_base_t, ds_thread),
120#endif
121
122    // team structure information
123    sizeof(kmp_base_team_t),
124    offset_and_size_of(kmp_base_team_t, t_master_tid),
125    offset_and_size_of(kmp_base_team_t, t_ident),
126    offset_and_size_of(kmp_base_team_t, t_parent),
127    offset_and_size_of(kmp_base_team_t, t_nproc),
128    offset_and_size_of(kmp_base_team_t, t_threads),
129    offset_and_size_of(kmp_base_team_t, t_serialized),
130    offset_and_size_of(kmp_base_team_t, t_id),
131    offset_and_size_of(kmp_base_team_t, t_pkfn),
132    offset_and_size_of(kmp_base_team_t, t_task_team),
133    offset_and_size_of(kmp_base_team_t, t_implicit_task_taskdata),
134    offset_and_size_of(kmp_base_team_t, t_cancel_request),
135    offset_and_size_of(kmp_base_team_t, t_bar),
136    offset_and_size_of(kmp_balign_team_t, b_master_arrived),
137    offset_and_size_of(kmp_balign_team_t, b_team_arrived),
138
139    // root structure information
140    sizeof(kmp_base_root_t),
141    offset_and_size_of(kmp_base_root_t, r_root_team),
142    offset_and_size_of(kmp_base_root_t, r_hot_team),
143    offset_and_size_of(kmp_base_root_t, r_uber_thread),
144    offset_and_size_not_available,
145
146    // ident structure information
147    sizeof(ident_t),
148    offset_and_size_of(ident_t, psource),
149    offset_and_size_of(ident_t, flags),
150
151    // lock structure information
152    sizeof(kmp_base_queuing_lock_t),
153    offset_and_size_of(kmp_base_queuing_lock_t, initialized),
154    offset_and_size_of(kmp_base_queuing_lock_t, location),
155    offset_and_size_of(kmp_base_queuing_lock_t, tail_id),
156    offset_and_size_of(kmp_base_queuing_lock_t, head_id),
157    offset_and_size_of(kmp_base_queuing_lock_t, next_ticket),
158    offset_and_size_of(kmp_base_queuing_lock_t, now_serving),
159    offset_and_size_of(kmp_base_queuing_lock_t, owner_id),
160    offset_and_size_of(kmp_base_queuing_lock_t, depth_locked),
161    offset_and_size_of(kmp_base_queuing_lock_t, flags),
162
163#if !KMP_USE_DYNAMIC_LOCK
164    /* Lock table. */
165    sizeof(kmp_lock_table_t),
166    offset_and_size_of(kmp_lock_table_t, used),
167    offset_and_size_of(kmp_lock_table_t, allocated),
168    offset_and_size_of(kmp_lock_table_t, table),
169#endif
170
171    // Task team structure information.
172    sizeof(kmp_base_task_team_t),
173    offset_and_size_of(kmp_base_task_team_t, tt_threads_data),
174    offset_and_size_of(kmp_base_task_team_t, tt_found_tasks),
175    offset_and_size_of(kmp_base_task_team_t, tt_nproc),
176    offset_and_size_of(kmp_base_task_team_t, tt_unfinished_threads),
177    offset_and_size_of(kmp_base_task_team_t, tt_active),
178
179    // task_data_t.
180    sizeof(kmp_taskdata_t),
181    offset_and_size_of(kmp_taskdata_t, td_task_id),
182    offset_and_size_of(kmp_taskdata_t, td_flags),
183    offset_and_size_of(kmp_taskdata_t, td_team),
184    offset_and_size_of(kmp_taskdata_t, td_parent),
185    offset_and_size_of(kmp_taskdata_t, td_level),
186    offset_and_size_of(kmp_taskdata_t, td_ident),
187    offset_and_size_of(kmp_taskdata_t, td_allocated_child_tasks),
188    offset_and_size_of(kmp_taskdata_t, td_incomplete_child_tasks),
189
190    offset_and_size_of(kmp_taskdata_t, td_taskwait_ident),
191    offset_and_size_of(kmp_taskdata_t, td_taskwait_counter),
192    offset_and_size_of(kmp_taskdata_t, td_taskwait_thread),
193
194    offset_and_size_of(kmp_taskdata_t, td_taskgroup),
195    offset_and_size_of(kmp_taskgroup_t, count),
196    offset_and_size_of(kmp_taskgroup_t, cancel_request),
197
198    offset_and_size_of(kmp_taskdata_t, td_depnode),
199    offset_and_size_of(kmp_depnode_list_t, node),
200    offset_and_size_of(kmp_depnode_list_t, next),
201    offset_and_size_of(kmp_base_depnode_t, successors),
202    offset_and_size_of(kmp_base_depnode_t, task),
203    offset_and_size_of(kmp_base_depnode_t, npredecessors),
204    offset_and_size_of(kmp_base_depnode_t, nrefs),
205    offset_and_size_of(kmp_task_t, routine),
206
207    // thread_data_t.
208    sizeof(kmp_thread_data_t),
209    offset_and_size_of(kmp_base_thread_data_t, td_deque),
210    offset_and_size_of(kmp_base_thread_data_t, td_deque_size),
211    offset_and_size_of(kmp_base_thread_data_t, td_deque_head),
212    offset_and_size_of(kmp_base_thread_data_t, td_deque_tail),
213    offset_and_size_of(kmp_base_thread_data_t, td_deque_ntasks),
214    offset_and_size_of(kmp_base_thread_data_t, td_deque_last_stolen),
215
216    // The last field.
217    KMP_OMP_VERSION,
218
219}; // __kmp_omp_debug_struct_info
220
221#undef offset_and_size_of
222#undef addr_and_size_of
223
224/* Intel compiler on IA-32 architecture issues a warning "conversion
225  from "unsigned long long" to "char *" may lose significant bits"
226  when 64-bit value is assigned to 32-bit pointer. Use this function
227  to suppress the warning. */
228static inline void *__kmp_convert_to_ptr(kmp_uint64 addr) {
229#if KMP_COMPILER_ICC
230#pragma warning(push)
231#pragma warning(disable : 810) // conversion from "unsigned long long" to "char
232// *" may lose significant bits
233#pragma warning(disable : 1195) // conversion from integer to smaller pointer
234#endif // KMP_COMPILER_ICC
235  return (void *)addr;
236#if KMP_COMPILER_ICC
237#pragma warning(pop)
238#endif // KMP_COMPILER_ICC
239} // __kmp_convert_to_ptr
240
241static int kmp_location_match(kmp_str_loc_t *loc, kmp_omp_nthr_item_t *item) {
242
243  int file_match = 0;
244  int func_match = 0;
245  int line_match = 0;
246
247  char *file = (char *)__kmp_convert_to_ptr(item->file);
248  char *func = (char *)__kmp_convert_to_ptr(item->func);
249  file_match = __kmp_str_fname_match(&loc->fname, file);
250  func_match =
251      item->func == 0 // If item->func is NULL, it allows any func name.
252      || strcmp(func, "*") == 0 ||
253      (loc->func != NULL && strcmp(loc->func, func) == 0);
254  line_match =
255      item->begin <= loc->line &&
256      (item->end <= 0 ||
257       loc->line <= item->end); // if item->end <= 0, it means "end of file".
258
259  return (file_match && func_match && line_match);
260
261} // kmp_location_match
262
263int __kmp_omp_num_threads(ident_t const *ident) {
264
265  int num_threads = 0;
266
267  kmp_omp_nthr_info_t *info = (kmp_omp_nthr_info_t *)__kmp_convert_to_ptr(
268      __kmp_omp_debug_struct_info.nthr_info.addr);
269  if (info->num > 0 && info->array != 0) {
270    kmp_omp_nthr_item_t *items =
271        (kmp_omp_nthr_item_t *)__kmp_convert_to_ptr(info->array);
272    kmp_str_loc_t loc = __kmp_str_loc_init(ident->psource, 1);
273    int i;
274    for (i = 0; i < info->num; ++i) {
275      if (kmp_location_match(&loc, &items[i])) {
276        num_threads = items[i].num_threads;
277      }
278    }
279    __kmp_str_loc_free(&loc);
280  }
281
282  return num_threads;
283  ;
284
285} // __kmp_omp_num_threads
286#endif /* USE_DEBUGGER */
287