1 /*
2 * Copyright © 2017 Google, Inc.
3 *
4 * This is part of HarfBuzz, a text shaping library.
5 *
6 * Permission is hereby granted, without written agreement and without
7 * license or royalty fees, to use, copy, modify, and distribute this
8 * software and its documentation for any purpose, provided that the
9 * above copyright notice and the following two paragraphs appear in
10 * all copies of this software.
11 *
12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16 * DAMAGE.
17 *
18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23 *
24 * Google Author(s): Behdad Esfahbod
25 */
26
27 #ifndef HB_DEBUG_HH
28 #define HB_DEBUG_HH
29
30 #include "hb.hh"
31 #include "hb-atomic.hh"
32 #include "hb-algs.hh"
33
34
35 #ifndef HB_DEBUG
36 #define HB_DEBUG 0
37 #endif
38
39
40 /*
41 * Global runtime options.
42 */
43
44 struct hb_options_t
45 {
46 bool unused : 1; /* In-case sign bit is here. */
47 bool initialized : 1;
48 bool uniscribe_bug_compatible : 1;
49 bool aat : 1;
50 };
51
52 union hb_options_union_t {
53 int i;
54 hb_options_t opts;
55 };
56 static_assert ((sizeof (hb_atomic_int_t) >= sizeof (hb_options_union_t)), "");
57
58 HB_INTERNAL void
59 _hb_options_init ();
60
61 extern HB_INTERNAL hb_atomic_int_t _hb_options;
62
63 static inline hb_options_t
hb_options()64 hb_options ()
65 {
66 #ifdef HB_NO_GETENV
67 return hb_options_t ();
68 #endif
69 /* Make a local copy, so we can access bitfield threadsafely. */
70 hb_options_union_t u;
71 u.i = _hb_options.get_relaxed ();
72
73 if (unlikely (!u.i))
74 {
75 _hb_options_init ();
76 u.i = _hb_options.get_relaxed ();
77 }
78
79 return u.opts;
80 }
81
82
83 /*
84 * Debug output (needs enabling at compile time.)
85 */
86
87 static inline bool
_hb_debug(unsigned int level,unsigned int max_level)88 _hb_debug (unsigned int level,
89 unsigned int max_level)
90 {
91 return level < max_level;
92 }
93
94 #define DEBUG_LEVEL_ENABLED(WHAT, LEVEL) (_hb_debug ((LEVEL), HB_DEBUG_##WHAT))
95 #define DEBUG_ENABLED(WHAT) (DEBUG_LEVEL_ENABLED (WHAT, 0))
96
97 static inline void
_hb_print_func(const char * func)98 _hb_print_func (const char *func)
99 {
100 if (func)
101 {
102 unsigned int func_len = strlen (func);
103 /* Skip "static" */
104 if (0 == strncmp (func, "static ", 7))
105 func += 7;
106 /* Skip "typename" */
107 if (0 == strncmp (func, "typename ", 9))
108 func += 9;
109 /* Skip return type */
110 const char *space = strchr (func, ' ');
111 if (space)
112 func = space + 1;
113 /* Skip parameter list */
114 const char *paren = strchr (func, '(');
115 if (paren)
116 func_len = paren - func;
117 fprintf (stderr, "%.*s", func_len, func);
118 }
119 }
120
121 template <int max_level> static inline void
122 _hb_debug_msg_va (const char *what,
123 const void *obj,
124 const char *func,
125 bool indented,
126 unsigned int level,
127 int level_dir,
128 const char *message,
129 va_list ap) HB_PRINTF_FUNC(7, 0);
130 template <int max_level> static inline void
_hb_debug_msg_va(const char * what,const void * obj,const char * func,bool indented,unsigned int level,int level_dir,const char * message,va_list ap)131 _hb_debug_msg_va (const char *what,
132 const void *obj,
133 const char *func,
134 bool indented,
135 unsigned int level,
136 int level_dir,
137 const char *message,
138 va_list ap)
139 {
140 if (!_hb_debug (level, max_level))
141 return;
142
143 fprintf (stderr, "%-10s", what ? what : "");
144
145 if (obj)
146 fprintf (stderr, "(%*p) ", (unsigned int) (2 * sizeof (void *)), obj);
147 else
148 fprintf (stderr, " %*s ", (unsigned int) (2 * sizeof (void *)), "");
149
150 if (indented) {
151 #define VBAR "\342\224\202" /* U+2502 BOX DRAWINGS LIGHT VERTICAL */
152 #define VRBAR "\342\224\234" /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
153 #define DLBAR "\342\225\256" /* U+256E BOX DRAWINGS LIGHT ARC DOWN AND LEFT */
154 #define ULBAR "\342\225\257" /* U+256F BOX DRAWINGS LIGHT ARC UP AND LEFT */
155 #define LBAR "\342\225\264" /* U+2574 BOX DRAWINGS LIGHT LEFT */
156 static const char bars[] =
157 VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
158 VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
159 VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
160 VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
161 VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR;
162 fprintf (stderr, "%2u %s" VRBAR "%s",
163 level,
164 bars + sizeof (bars) - 1 - hb_min ((unsigned int) sizeof (bars) - 1, (unsigned int) (sizeof (VBAR) - 1) * level),
165 level_dir ? (level_dir > 0 ? DLBAR : ULBAR) : LBAR);
166 } else
167 fprintf (stderr, " " VRBAR LBAR);
168
169 _hb_print_func (func);
170
171 if (message)
172 {
173 fprintf (stderr, ": ");
174 vfprintf (stderr, message, ap);
175 }
176
177 fprintf (stderr, "\n");
178 }
179 template <> inline void HB_PRINTF_FUNC(7, 0)
_hb_debug_msg_va(const char * what HB_UNUSED,const void * obj HB_UNUSED,const char * func HB_UNUSED,bool indented HB_UNUSED,unsigned int level HB_UNUSED,int level_dir HB_UNUSED,const char * message HB_UNUSED,va_list ap HB_UNUSED)180 _hb_debug_msg_va<0> (const char *what HB_UNUSED,
181 const void *obj HB_UNUSED,
182 const char *func HB_UNUSED,
183 bool indented HB_UNUSED,
184 unsigned int level HB_UNUSED,
185 int level_dir HB_UNUSED,
186 const char *message HB_UNUSED,
187 va_list ap HB_UNUSED) {}
188
189 template <int max_level> static inline void
190 _hb_debug_msg (const char *what,
191 const void *obj,
192 const char *func,
193 bool indented,
194 unsigned int level,
195 int level_dir,
196 const char *message,
197 ...) HB_PRINTF_FUNC(7, 8);
198 template <int max_level> static inline void HB_PRINTF_FUNC(7, 8)
_hb_debug_msg(const char * what,const void * obj,const char * func,bool indented,unsigned int level,int level_dir,const char * message,...)199 _hb_debug_msg (const char *what,
200 const void *obj,
201 const char *func,
202 bool indented,
203 unsigned int level,
204 int level_dir,
205 const char *message,
206 ...)
207 {
208 va_list ap;
209 va_start (ap, message);
210 _hb_debug_msg_va<max_level> (what, obj, func, indented, level, level_dir, message, ap);
211 va_end (ap);
212 }
213 template <> inline void
214 _hb_debug_msg<0> (const char *what HB_UNUSED,
215 const void *obj HB_UNUSED,
216 const char *func HB_UNUSED,
217 bool indented HB_UNUSED,
218 unsigned int level HB_UNUSED,
219 int level_dir HB_UNUSED,
220 const char *message HB_UNUSED,
221 ...) HB_PRINTF_FUNC(7, 8);
222 template <> inline void HB_PRINTF_FUNC(7, 8)
_hb_debug_msg(const char * what HB_UNUSED,const void * obj HB_UNUSED,const char * func HB_UNUSED,bool indented HB_UNUSED,unsigned int level HB_UNUSED,int level_dir HB_UNUSED,const char * message HB_UNUSED,...)223 _hb_debug_msg<0> (const char *what HB_UNUSED,
224 const void *obj HB_UNUSED,
225 const char *func HB_UNUSED,
226 bool indented HB_UNUSED,
227 unsigned int level HB_UNUSED,
228 int level_dir HB_UNUSED,
229 const char *message HB_UNUSED,
230 ...) {}
231
232 #define DEBUG_MSG_LEVEL(WHAT, OBJ, LEVEL, LEVEL_DIR, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), nullptr, true, (LEVEL), (LEVEL_DIR), __VA_ARGS__)
233 #define DEBUG_MSG(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), nullptr, false, 0, 0, __VA_ARGS__)
234 #define DEBUG_MSG_FUNC(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), HB_FUNC, false, 0, 0, __VA_ARGS__)
235
236
237 /*
238 * Printer
239 */
240
241 template <typename T>
242 struct hb_printer_t {
printhb_printer_t243 const char *print (const T&) { return "something"; }
244 };
245
246 template <>
247 struct hb_printer_t<bool> {
printhb_printer_t248 const char *print (bool v) { return v ? "true" : "false"; }
249 };
250
251 template <>
252 struct hb_printer_t<hb_empty_t> {
printhb_printer_t253 const char *print (hb_empty_t) { return ""; }
254 };
255
256
257 /*
258 * Trace
259 */
260
261 template <typename T>
_hb_warn_no_return(bool returned)262 static inline void _hb_warn_no_return (bool returned)
263 {
264 if (unlikely (!returned)) {
265 fprintf (stderr, "OUCH, returned with no call to return_trace(). This is a bug, please report.\n");
266 }
267 }
268 template <>
_hb_warn_no_return(bool returned HB_UNUSED)269 /*static*/ inline void _hb_warn_no_return<hb_empty_t> (bool returned HB_UNUSED)
270 {}
271
272 template <int max_level, typename ret_t>
273 struct hb_auto_trace_t
274 {
hb_auto_trace_thb_auto_trace_t275 explicit inline hb_auto_trace_t (unsigned int *plevel_,
276 const char *what_,
277 const void *obj_,
278 const char *func,
279 const char *message,
280 ...) HB_PRINTF_FUNC(6, 7)
281 : plevel (plevel_), what (what_), obj (obj_), returned (false)
282 {
283 if (plevel) ++*plevel;
284
285 va_list ap;
286 va_start (ap, message);
287 _hb_debug_msg_va<max_level> (what, obj, func, true, plevel ? *plevel : 0, +1, message, ap);
288 va_end (ap);
289 }
~hb_auto_trace_thb_auto_trace_t290 ~hb_auto_trace_t ()
291 {
292 _hb_warn_no_return<ret_t> (returned);
293 if (!returned) {
294 _hb_debug_msg<max_level> (what, obj, nullptr, true, plevel ? *plevel : 1, -1, " ");
295 }
296 if (plevel) --*plevel;
297 }
298
299 template <typename T>
rethb_auto_trace_t300 T ret (T&& v,
301 const char *func = "",
302 unsigned int line = 0)
303 {
304 if (unlikely (returned)) {
305 fprintf (stderr, "OUCH, double calls to return_trace(). This is a bug, please report.\n");
306 return hb_forward<T> (v);
307 }
308
309 _hb_debug_msg<max_level> (what, obj, func, true, plevel ? *plevel : 1, -1,
310 "return %s (line %d)",
311 hb_printer_t<decltype (v)>().print (v), line);
312 if (plevel) --*plevel;
313 plevel = nullptr;
314 returned = true;
315 return hb_forward<T> (v);
316 }
317
318 private:
319 unsigned int *plevel;
320 const char *what;
321 const void *obj;
322 bool returned;
323 };
324 template <typename ret_t> /* Make sure we don't use hb_auto_trace_t when not tracing. */
325 struct hb_auto_trace_t<0, ret_t>
326 {
hb_auto_trace_thb_auto_trace_t327 explicit inline hb_auto_trace_t (unsigned int *plevel_,
328 const char *what_,
329 const void *obj_,
330 const char *func,
331 const char *message,
332 ...) HB_PRINTF_FUNC(6, 7) {}
333
334 template <typename T>
rethb_auto_trace_t335 T ret (T&& v,
336 const char *func HB_UNUSED = nullptr,
337 unsigned int line HB_UNUSED = 0) { return hb_forward<T> (v); }
338 };
339
340 /* For disabled tracing; optimize out everything.
341 * https://github.com/harfbuzz/harfbuzz/pull/605 */
342 template <typename ret_t>
343 struct hb_no_trace_t {
344 template <typename T>
rethb_no_trace_t345 T ret (T&& v,
346 const char *func HB_UNUSED = nullptr,
347 unsigned int line HB_UNUSED = 0) { return hb_forward<T> (v); }
348 };
349
350 #define return_trace(RET) return trace.ret (RET, HB_FUNC, __LINE__)
351
352
353 /*
354 * Instances.
355 */
356
357 #ifndef HB_DEBUG_ARABIC
358 #define HB_DEBUG_ARABIC (HB_DEBUG+0)
359 #endif
360
361 #ifndef HB_DEBUG_BLOB
362 #define HB_DEBUG_BLOB (HB_DEBUG+0)
363 #endif
364
365 #ifndef HB_DEBUG_CORETEXT
366 #define HB_DEBUG_CORETEXT (HB_DEBUG+0)
367 #endif
368
369 #ifndef HB_DEBUG_DIRECTWRITE
370 #define HB_DEBUG_DIRECTWRITE (HB_DEBUG+0)
371 #endif
372
373 #ifndef HB_DEBUG_FT
374 #define HB_DEBUG_FT (HB_DEBUG+0)
375 #endif
376
377 #ifndef HB_DEBUG_GET_COVERAGE
378 #define HB_DEBUG_GET_COVERAGE (HB_DEBUG+0)
379 #endif
380
381 #ifndef HB_DEBUG_OBJECT
382 #define HB_DEBUG_OBJECT (HB_DEBUG+0)
383 #endif
384
385 #ifndef HB_DEBUG_SHAPE_PLAN
386 #define HB_DEBUG_SHAPE_PLAN (HB_DEBUG+0)
387 #endif
388
389 #ifndef HB_DEBUG_UNISCRIBE
390 #define HB_DEBUG_UNISCRIBE (HB_DEBUG+0)
391 #endif
392
393 /*
394 * With tracing.
395 */
396
397 #ifndef HB_DEBUG_APPLY
398 #define HB_DEBUG_APPLY (HB_DEBUG+0)
399 #endif
400 #if HB_DEBUG_APPLY
401 #define TRACE_APPLY(this) \
402 hb_auto_trace_t<HB_DEBUG_APPLY, bool> trace \
403 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
404 "idx %d gid %u lookup %d", \
405 c->buffer->idx, c->buffer->cur().codepoint, (int) c->lookup_index)
406 #else
407 #define TRACE_APPLY(this) hb_no_trace_t<bool> trace
408 #endif
409
410 #ifndef HB_DEBUG_SANITIZE
411 #define HB_DEBUG_SANITIZE (HB_DEBUG+0)
412 #endif
413 #if HB_DEBUG_SANITIZE
414 #define TRACE_SANITIZE(this) \
415 hb_auto_trace_t<HB_DEBUG_SANITIZE, bool> trace \
416 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
417 " ")
418 #else
419 #define TRACE_SANITIZE(this) hb_no_trace_t<bool> trace
420 #endif
421
422 #ifndef HB_DEBUG_SERIALIZE
423 #define HB_DEBUG_SERIALIZE (HB_DEBUG+0)
424 #endif
425 #if HB_DEBUG_SERIALIZE
426 #define TRACE_SERIALIZE(this) \
427 hb_auto_trace_t<HB_DEBUG_SERIALIZE, bool> trace \
428 (&c->debug_depth, "SERIALIZE", c, HB_FUNC, \
429 " ")
430 #else
431 #define TRACE_SERIALIZE(this) hb_no_trace_t<bool> trace
432 #endif
433
434 #ifndef HB_DEBUG_SUBSET
435 #define HB_DEBUG_SUBSET (HB_DEBUG+0)
436 #endif
437 #if HB_DEBUG_SUBSET
438 #define TRACE_SUBSET(this) \
439 hb_auto_trace_t<HB_DEBUG_SUBSET, bool> trace \
440 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
441 " ")
442 #else
443 #define TRACE_SUBSET(this) hb_no_trace_t<bool> trace
444 #endif
445
446 #ifndef HB_DEBUG_DISPATCH
447 #define HB_DEBUG_DISPATCH ( \
448 HB_DEBUG_APPLY + \
449 HB_DEBUG_SANITIZE + \
450 HB_DEBUG_SERIALIZE + \
451 HB_DEBUG_SUBSET + \
452 0)
453 #endif
454 #if HB_DEBUG_DISPATCH
455 #define TRACE_DISPATCH(this, format) \
456 hb_auto_trace_t<context_t::max_debug_depth, typename context_t::return_t> trace \
457 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
458 "format %d", (int) format)
459 #else
460 #define TRACE_DISPATCH(this, format) hb_no_trace_t<typename context_t::return_t> trace
461 #endif
462
463
464 #endif /* HB_DEBUG_HH */
465