gfx/harfbuzz/src/hb-debug.hh

   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 };
  50
  51 union hb_options_union_t {
  52   int i;
  53   hb_options_t opts;
  54 };
  55 static_assert ((sizeof (hb_atomic_int_t) >= sizeof (hb_options_union_t)), "");
  56
  57 HB_INTERNAL void
  58 _hb_options_init ();
  59
  60 extern HB_INTERNAL hb_atomic_int_t _hb_options;
  61
  62 static inline hb_options_t
  63 hb_options ()
  64 {
  65 #ifdef HB_NO_GETENV
  66   return hb_options_t ();
  67 #endif
  68   /* Make a local copy, so we can access bitfield threadsafely. */
  69   hb_options_union_t u;
  70   u.i = _hb_options;
  71
  72   if (unlikely (!u.i))
  73   {
  74     _hb_options_init ();
  75     u.i = _hb_options;
  76   }
  77
  78   return u.opts;
  79 }
  80
  81
  82 /*
  83  * Debug output (needs enabling at compile time.)
  84  */
  85
  86 static inline bool
  87 _hb_debug (unsigned int level,
  88            unsigned int max_level)
  89 {
  90   return level < max_level;
  91 }
  92
  93 #define DEBUG_LEVEL_ENABLED(WHAT, LEVEL) (_hb_debug ((LEVEL), HB_DEBUG_##WHAT))
  94 #define DEBUG_ENABLED(WHAT) (DEBUG_LEVEL_ENABLED (WHAT, 0))
  95
  96 static inline void
  97 _hb_print_func (const char *func)
  98 {
  99   if (func)
 100   {
 101     unsigned int func_len = strlen (func);
 102     /* Skip "static" */
 103     if (0 == strncmp (func, "static ", 7))
 104       func += 7;
 105     /* Skip "typename" */
 106     if (0 == strncmp (func, "typename ", 9))
 107       func += 9;
 108     /* Skip return type */
 109     const char *space = strchr (func, ' ');
 110     if (space)
 111       func = space + 1;
 112     /* Skip parameter list */
 113     const char *paren = strchr (func, '(');
 114     if (paren)
 115       func_len = paren - func;
 116     fprintf (stderr, "%.*s", (int) func_len, func);
 117   }
 118 }
 119
 120 template <int max_level> static inline void
 121 _hb_debug_msg_va (const char *what,
 122                   const void *obj,
 123                   const char *func,
 124                   bool indented,
 125                   unsigned int level,
 126                   int level_dir,
 127                   const char *message,
 128                   va_list ap) HB_PRINTF_FUNC(7, 0);
 129 template <int max_level> static inline void
 130 _hb_debug_msg_va (const char *what,
 131                   const void *obj,
 132                   const char *func,
 133                   bool indented,
 134                   unsigned int level,
 135                   int level_dir,
 136                   const char *message,
 137                   va_list ap)
 138 {
 139   if (!_hb_debug (level, max_level))
 140     return;
 141
 142   fprintf (stderr, "%-10s", what ? what : "");
 143
 144   if (obj)
 145     fprintf (stderr, "(%*p) ", (int) (2 * sizeof (void *)), obj);
 146   else
 147     fprintf (stderr, " %*s  ", (int) (2 * sizeof (void *)), "");
 148
 149   if (indented) {
 150 #define VBAR    "\342\224\202"  /* U+2502 BOX DRAWINGS LIGHT VERTICAL */
 151 #define VRBAR   "\342\224\234"  /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
 152 #define DLBAR   "\342\225\256"  /* U+256E BOX DRAWINGS LIGHT ARC DOWN AND LEFT */
 153 #define ULBAR   "\342\225\257"  /* U+256F BOX DRAWINGS LIGHT ARC UP AND LEFT */
 154 #define LBAR    "\342\225\264"  /* U+2574 BOX DRAWINGS LIGHT LEFT */
 155     static const char bars[] =
 156       VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
 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     fprintf (stderr, "%2u %s" VRBAR "%s",
 162              level,
 163              bars + sizeof (bars) - 1 - hb_min ((unsigned int) sizeof (bars) - 1, (unsigned int) (sizeof (VBAR) - 1) * level),
 164              level_dir ? (level_dir > 0 ? DLBAR : ULBAR) : LBAR);
 165   } else
 166     fprintf (stderr, "   " VRBAR LBAR);
 167
 168   _hb_print_func (func);
 169
 170   if (message)
 171   {
 172     fprintf (stderr, ": ");
 173     vfprintf (stderr, message, ap);
 174   }
 175
 176   fprintf (stderr, "\n");
 177 }
 178 template <> inline void HB_PRINTF_FUNC(7, 0)
 179 _hb_debug_msg_va<0> (const char *what HB_UNUSED,
 180                      const void *obj HB_UNUSED,
 181                      const char *func HB_UNUSED,
 182                      bool indented HB_UNUSED,
 183                      unsigned int level HB_UNUSED,
 184                      int level_dir HB_UNUSED,
 185                      const char *message HB_UNUSED,
 186                      va_list ap HB_UNUSED) {}
 187
 188 template <int max_level> static inline void
 189 _hb_debug_msg (const char *what,
 190                const void *obj,
 191                const char *func,
 192                bool indented,
 193                unsigned int level,
 194                int level_dir,
 195                const char *message,
 196                ...) HB_PRINTF_FUNC(7, 8);
 197 template <int max_level> static inline void HB_PRINTF_FUNC(7, 8)
 198 _hb_debug_msg (const char *what,
 199                const void *obj,
 200                const char *func,
 201                bool indented,
 202                unsigned int level,
 203                int level_dir,
 204                const char *message,
 205                ...)
 206 {
 207   va_list ap;
 208   va_start (ap, message);
 209   _hb_debug_msg_va<max_level> (what, obj, func, indented, level, level_dir, message, ap);
 210   va_end (ap);
 211 }
 212 template <> inline void
 213 _hb_debug_msg<0> (const char *what HB_UNUSED,
 214                   const void *obj HB_UNUSED,
 215                   const char *func HB_UNUSED,
 216                   bool indented HB_UNUSED,
 217                   unsigned int level HB_UNUSED,
 218                   int level_dir HB_UNUSED,
 219                   const char *message HB_UNUSED,
 220                   ...) HB_PRINTF_FUNC(7, 8);
 221 template <> inline void HB_PRINTF_FUNC(7, 8)
 222 _hb_debug_msg<0> (const char *what HB_UNUSED,
 223                   const void *obj HB_UNUSED,
 224                   const char *func HB_UNUSED,
 225                   bool indented HB_UNUSED,
 226                   unsigned int level HB_UNUSED,
 227                   int level_dir HB_UNUSED,
 228                   const char *message HB_UNUSED,
 229                   ...) {}
 230
 231 #define DEBUG_MSG_LEVEL(WHAT, OBJ, LEVEL, LEVEL_DIR, ...)       _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), nullptr,    true, (LEVEL), (LEVEL_DIR), __VA_ARGS__)
 232 #define DEBUG_MSG(WHAT, OBJ, ...)                               _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), nullptr,    false, 0, 0, __VA_ARGS__)
 233 #define DEBUG_MSG_FUNC(WHAT, OBJ, ...)                          _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), HB_FUNC, false, 0, 0, __VA_ARGS__)
 234
 235
 236 /*
 237  * Printer
 238  */
 239
 240 template <typename T>
 241 struct hb_printer_t {
 242   const char *print (const T&) { return "something"; }
 243 };
 244
 245 template <>
 246 struct hb_printer_t<bool> {
 247   const char *print (bool v) { return v ? "true" : "false"; }
 248 };
 249
 250 template <>
 251 struct hb_printer_t<hb_empty_t> {
 252   const char *print (hb_empty_t) { return ""; }
 253 };
 254
 255
 256 /*
 257  * Trace
 258  */
 259
 260 template <typename T>
 261 static inline void _hb_warn_no_return (bool returned)
 262 {
 263   if (unlikely (!returned)) {
 264     fprintf (stderr, "OUCH, returned with no call to return_trace().  This is a bug, please report.\n");
 265   }
 266 }
 267 template <>
 268 /*static*/ inline void _hb_warn_no_return<hb_empty_t> (bool returned HB_UNUSED) {}
 269 template <>
 270 /*static*/ inline void _hb_warn_no_return<void> (bool returned HB_UNUSED) {}
 271
 272 template <int max_level, typename ret_t>
 273 struct hb_auto_trace_t
 274 {
 275   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   }
 290   ~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>
 300   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 std::forward<T> (v);
 307     }
 308
 309     _hb_debug_msg<max_level> (what, obj, func, true, plevel ? *plevel : 1, -1,
 310                               "return %s (line %u)",
 311                               hb_printer_t<hb_decay<decltype (v)>>().print (v), line);
 312     if (plevel) --*plevel;
 313     plevel = nullptr;
 314     returned = true;
 315     return std::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 {
 327   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>
 335   T ret (T&& v,
 336          const char *func HB_UNUSED = nullptr,
 337          unsigned int line HB_UNUSED = 0) { return std::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>
 345   T ret (T&& v,
 346          const char *func HB_UNUSED = nullptr,
 347          unsigned int line HB_UNUSED = 0) { return std::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_JUSTIFY
 378 #define HB_DEBUG_JUSTIFY (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 #ifndef HB_DEBUG_WASM
 394 #define HB_DEBUG_WASM (HB_DEBUG+0)
 395 #endif
 396
 397 /*
 398  * With tracing.
 399  */
 400
 401 #ifndef HB_DEBUG_APPLY
 402 #define HB_DEBUG_APPLY (HB_DEBUG+0)
 403 #endif
 404 #if HB_DEBUG_APPLY
 405 #define TRACE_APPLY(this) \
 406         hb_auto_trace_t<HB_DEBUG_APPLY, bool> trace \
 407         (&c->debug_depth, c->get_name (), this, HB_FUNC, \
 408          "idx %u gid %u lookup %d", \
 409          c->buffer->idx, c->buffer->cur().codepoint, (int) c->lookup_index)
 410 #else
 411 #define TRACE_APPLY(this) hb_no_trace_t<bool> trace
 412 #endif
 413
 414 #ifndef HB_DEBUG_SANITIZE
 415 #define HB_DEBUG_SANITIZE (HB_DEBUG+0)
 416 #endif
 417 #if HB_DEBUG_SANITIZE
 418 #define TRACE_SANITIZE(this) \
 419         hb_auto_trace_t<HB_DEBUG_SANITIZE, bool> trace \
 420         (&c->debug_depth, c->get_name (), this, HB_FUNC, \
 421          " ")
 422 #else
 423 #define TRACE_SANITIZE(this) hb_no_trace_t<bool> trace
 424 #endif
 425
 426 #ifndef HB_DEBUG_SERIALIZE
 427 #define HB_DEBUG_SERIALIZE (HB_DEBUG+0)
 428 #endif
 429 #if HB_DEBUG_SERIALIZE
 430 #define TRACE_SERIALIZE(this) \
 431         hb_auto_trace_t<HB_DEBUG_SERIALIZE, bool> trace \
 432         (&c->debug_depth, "SERIALIZE", c, HB_FUNC, \
 433          " ")
 434 #else
 435 #define TRACE_SERIALIZE(this) hb_no_trace_t<bool> trace
 436 #endif
 437
 438 #ifndef HB_DEBUG_SUBSET
 439 #define HB_DEBUG_SUBSET (HB_DEBUG+0)
 440 #endif
 441 #if HB_DEBUG_SUBSET
 442 #define TRACE_SUBSET(this) \
 443   hb_auto_trace_t<HB_DEBUG_SUBSET, bool> trace \
 444   (&c->debug_depth, c->get_name (), this, HB_FUNC, \
 445    " ")
 446 #else
 447 #define TRACE_SUBSET(this) hb_no_trace_t<bool> trace
 448 #endif
 449
 450 #ifndef HB_DEBUG_SUBSET_REPACK
 451 #define HB_DEBUG_SUBSET_REPACK (HB_DEBUG+0)
 452 #endif
 453
 454 #ifndef HB_DEBUG_PAINT
 455 #define HB_DEBUG_PAINT (HB_DEBUG+0)
 456 #endif
 457 #if HB_DEBUG_PAINT
 458 #define TRACE_PAINT(this) \
 459   HB_UNUSED hb_auto_trace_t<HB_DEBUG_PAINT, void> trace \
 460   (&c->debug_depth, c->get_name (), this, HB_FUNC, \
 461    " ")
 462 #else
 463 #define TRACE_PAINT(this) HB_UNUSED hb_no_trace_t<void> trace
 464 #endif
 465
 466
 467 #ifndef HB_DEBUG_DISPATCH
 468 #define HB_DEBUG_DISPATCH ( \
 469         HB_DEBUG_APPLY + \
 470         HB_DEBUG_SANITIZE + \
 471         HB_DEBUG_SERIALIZE + \
 472         HB_DEBUG_SUBSET + \
 473         HB_DEBUG_PAINT + \
 474         0)
 475 #endif
 476 #if HB_DEBUG_DISPATCH
 477 #define TRACE_DISPATCH(this, format) \
 478         hb_auto_trace_t<context_t::max_debug_depth, typename context_t::return_t> trace \
 479         (&c->debug_depth, c->get_name (), this, HB_FUNC, \
 480          "format %u", (unsigned) format)
 481 #else
 482 #define TRACE_DISPATCH(this, format) hb_no_trace_t<typename context_t::return_t> trace
 483 #endif
 484
 485
 486 #ifndef HB_BUFFER_MESSAGE_MORE
 487 #define HB_BUFFER_MESSAGE_MORE (HB_DEBUG+1)
 488 #endif
 489
 490
 491 #endif /* HB_DEBUG_HH */