|
150
|
1 /*
|
|
|
2 * kmp_io.cpp -- RTL IO
|
|
|
3 */
|
|
|
4
|
|
|
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 //===----------------------------------------------------------------------===//
|
|
|
12
|
|
|
13 #include <stdarg.h>
|
|
|
14 #include <stddef.h>
|
|
|
15 #include <stdio.h>
|
|
|
16 #include <stdlib.h>
|
|
|
17 #include <string.h>
|
|
|
18 #ifndef __ABSOFT_WIN
|
|
|
19 #include <sys/types.h>
|
|
|
20 #endif
|
|
|
21
|
|
|
22 #include "kmp.h" // KMP_GTID_DNE, __kmp_debug_buf, etc
|
|
|
23 #include "kmp_io.h"
|
|
|
24 #include "kmp_lock.h"
|
|
|
25 #include "kmp_os.h"
|
|
|
26 #include "kmp_str.h"
|
|
|
27
|
|
|
28 #if KMP_OS_WINDOWS
|
|
|
29 #if KMP_MSVC_COMPAT
|
|
|
30 #pragma warning(push)
|
|
|
31 #pragma warning(disable : 271 310)
|
|
|
32 #endif
|
|
|
33 #include <windows.h>
|
|
|
34 #if KMP_MSVC_COMPAT
|
|
|
35 #pragma warning(pop)
|
|
|
36 #endif
|
|
|
37 #endif
|
|
|
38
|
|
|
39 /* ------------------------------------------------------------------------ */
|
|
|
40
|
|
|
41 kmp_bootstrap_lock_t __kmp_stdio_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
|
|
|
42 __kmp_stdio_lock); /* Control stdio functions */
|
|
|
43 kmp_bootstrap_lock_t __kmp_console_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
|
|
|
44 __kmp_console_lock); /* Control console initialization */
|
|
|
45
|
|
|
46 #if KMP_OS_WINDOWS
|
|
|
47
|
|
|
48 static HANDLE __kmp_stdout = NULL;
|
|
|
49 static HANDLE __kmp_stderr = NULL;
|
|
|
50 static int __kmp_console_exists = FALSE;
|
|
|
51 static kmp_str_buf_t __kmp_console_buf;
|
|
|
52
|
|
|
53 static int is_console(void) {
|
|
|
54 char buffer[128];
|
|
|
55 DWORD rc = 0;
|
|
|
56 DWORD err = 0;
|
|
|
57 // Try to get console title.
|
|
|
58 SetLastError(0);
|
|
|
59 // GetConsoleTitle does not reset last error in case of success or short
|
|
|
60 // buffer, so we need to clear it explicitly.
|
|
|
61 rc = GetConsoleTitle(buffer, sizeof(buffer));
|
|
|
62 if (rc == 0) {
|
|
|
63 // rc == 0 means getting console title failed. Let us find out why.
|
|
|
64 err = GetLastError();
|
|
|
65 // err == 0 means buffer too short (we suppose console exists).
|
|
|
66 // In Window applications we usually have err == 6 (invalid handle).
|
|
|
67 }
|
|
|
68 return rc > 0 || err == 0;
|
|
|
69 }
|
|
|
70
|
|
|
71 void __kmp_close_console(void) {
|
|
|
72 /* wait until user presses return before closing window */
|
|
|
73 /* TODO only close if a window was opened */
|
|
|
74 if (__kmp_console_exists) {
|
|
|
75 __kmp_stdout = NULL;
|
|
|
76 __kmp_stderr = NULL;
|
|
|
77 __kmp_str_buf_free(&__kmp_console_buf);
|
|
|
78 __kmp_console_exists = FALSE;
|
|
|
79 }
|
|
|
80 }
|
|
|
81
|
|
|
82 /* For windows, call this before stdout, stderr, or stdin are used.
|
|
|
83 It opens a console window and starts processing */
|
|
|
84 static void __kmp_redirect_output(void) {
|
|
|
85 __kmp_acquire_bootstrap_lock(&__kmp_console_lock);
|
|
|
86
|
|
|
87 if (!__kmp_console_exists) {
|
|
|
88 HANDLE ho;
|
|
|
89 HANDLE he;
|
|
|
90
|
|
|
91 __kmp_str_buf_init(&__kmp_console_buf);
|
|
|
92
|
|
|
93 AllocConsole();
|
|
|
94 // We do not check the result of AllocConsole because
|
|
|
95 // 1. the call is harmless
|
|
|
96 // 2. it is not clear how to communicate failue
|
|
|
97 // 3. we will detect failure later when we get handle(s)
|
|
|
98
|
|
|
99 ho = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
100 if (ho == INVALID_HANDLE_VALUE || ho == NULL) {
|
|
|
101
|
|
|
102 DWORD err = GetLastError();
|
|
|
103 // TODO: output error somehow (maybe message box)
|
|
|
104 __kmp_stdout = NULL;
|
|
|
105
|
|
|
106 } else {
|
|
|
107
|
|
|
108 __kmp_stdout = ho; // temporary code, need new global for ho
|
|
|
109 }
|
|
|
110 he = GetStdHandle(STD_ERROR_HANDLE);
|
|
|
111 if (he == INVALID_HANDLE_VALUE || he == NULL) {
|
|
|
112
|
|
|
113 DWORD err = GetLastError();
|
|
|
114 // TODO: output error somehow (maybe message box)
|
|
|
115 __kmp_stderr = NULL;
|
|
|
116
|
|
|
117 } else {
|
|
|
118
|
|
|
119 __kmp_stderr = he; // temporary code, need new global
|
|
|
120 }
|
|
|
121 __kmp_console_exists = TRUE;
|
|
|
122 }
|
|
|
123 __kmp_release_bootstrap_lock(&__kmp_console_lock);
|
|
|
124 }
|
|
|
125
|
|
|
126 #else
|
|
|
127 #define __kmp_stderr (stderr)
|
|
|
128 #define __kmp_stdout (stdout)
|
|
|
129 #endif /* KMP_OS_WINDOWS */
|
|
|
130
|
|
|
131 void __kmp_vprintf(enum kmp_io out_stream, char const *format, va_list ap) {
|
|
|
132 #if KMP_OS_WINDOWS
|
|
|
133 if (!__kmp_console_exists) {
|
|
|
134 __kmp_redirect_output();
|
|
|
135 }
|
|
|
136 if (!__kmp_stderr && out_stream == kmp_err) {
|
|
|
137 return;
|
|
|
138 }
|
|
|
139 if (!__kmp_stdout && out_stream == kmp_out) {
|
|
|
140 return;
|
|
|
141 }
|
|
|
142 #endif /* KMP_OS_WINDOWS */
|
|
|
143 auto stream = ((out_stream == kmp_out) ? __kmp_stdout : __kmp_stderr);
|
|
|
144
|
|
|
145 if (__kmp_debug_buf && __kmp_debug_buffer != NULL) {
|
|
|
146
|
|
|
147 int dc = __kmp_debug_count++ % __kmp_debug_buf_lines;
|
|
|
148 char *db = &__kmp_debug_buffer[dc * __kmp_debug_buf_chars];
|
|
|
149 int chars = 0;
|
|
|
150
|
|
|
151 #ifdef KMP_DEBUG_PIDS
|
|
|
152 chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars, "pid=%d: ",
|
|
|
153 (kmp_int32)getpid());
|
|
|
154 #endif
|
|
|
155 chars += KMP_VSNPRINTF(db, __kmp_debug_buf_chars, format, ap);
|
|
|
156
|
|
|
157 if (chars + 1 > __kmp_debug_buf_chars) {
|
|
|
158 if (chars + 1 > __kmp_debug_buf_warn_chars) {
|
|
|
159 #if KMP_OS_WINDOWS
|
|
|
160 DWORD count;
|
|
|
161 __kmp_str_buf_print(&__kmp_console_buf, "OMP warning: Debugging buffer "
|
|
|
162 "overflow; increase "
|
|
|
163 "KMP_DEBUG_BUF_CHARS to %d\n",
|
|
|
164 chars + 1);
|
|
|
165 WriteFile(stream, __kmp_console_buf.str, __kmp_console_buf.used, &count,
|
|
|
166 NULL);
|
|
|
167 __kmp_str_buf_clear(&__kmp_console_buf);
|
|
|
168 #else
|
|
|
169 fprintf(stream, "OMP warning: Debugging buffer overflow; "
|
|
|
170 "increase KMP_DEBUG_BUF_CHARS to %d\n",
|
|
|
171 chars + 1);
|
|
|
172 fflush(stream);
|
|
|
173 #endif
|
|
|
174 __kmp_debug_buf_warn_chars = chars + 1;
|
|
|
175 }
|
|
|
176 /* terminate string if overflow occurred */
|
|
|
177 db[__kmp_debug_buf_chars - 2] = '\n';
|
|
|
178 db[__kmp_debug_buf_chars - 1] = '\0';
|
|
|
179 }
|
|
|
180 } else {
|
|
|
181 #if KMP_OS_WINDOWS
|
|
|
182 DWORD count;
|
|
|
183 #ifdef KMP_DEBUG_PIDS
|
|
|
184 __kmp_str_buf_print(&__kmp_console_buf, "pid=%d: ", (kmp_int32)getpid());
|
|
|
185 #endif
|
|
|
186 __kmp_str_buf_vprint(&__kmp_console_buf, format, ap);
|
|
|
187 WriteFile(stream, __kmp_console_buf.str, __kmp_console_buf.used, &count,
|
|
|
188 NULL);
|
|
|
189 __kmp_str_buf_clear(&__kmp_console_buf);
|
|
|
190 #else
|
|
|
191 #ifdef KMP_DEBUG_PIDS
|
|
|
192 fprintf(stream, "pid=%d: ", (kmp_int32)getpid());
|
|
|
193 #endif
|
|
|
194 vfprintf(stream, format, ap);
|
|
|
195 fflush(stream);
|
|
|
196 #endif
|
|
|
197 }
|
|
|
198 }
|
|
|
199
|
|
|
200 void __kmp_printf(char const *format, ...) {
|
|
|
201 va_list ap;
|
|
|
202 va_start(ap, format);
|
|
|
203
|
|
|
204 __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
|
|
|
205 __kmp_vprintf(kmp_err, format, ap);
|
|
|
206 __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
|
|
|
207
|
|
|
208 va_end(ap);
|
|
|
209 }
|
|
|
210
|
|
|
211 void __kmp_printf_no_lock(char const *format, ...) {
|
|
|
212 va_list ap;
|
|
|
213 va_start(ap, format);
|
|
|
214
|
|
|
215 __kmp_vprintf(kmp_err, format, ap);
|
|
|
216
|
|
|
217 va_end(ap);
|
|
|
218 }
|
|
|
219
|
|
|
220 void __kmp_fprintf(enum kmp_io stream, char const *format, ...) {
|
|
|
221 va_list ap;
|
|
|
222 va_start(ap, format);
|
|
|
223
|
|
|
224 __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
|
|
|
225 __kmp_vprintf(stream, format, ap);
|
|
|
226 __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
|
|
|
227
|
|
|
228 va_end(ap);
|
|
|
229 }
|
