deps/lightning/lib/jit_print.c

   1 /*
   2  * Copyright (C) 2012-2019  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #include <lightning.h>
  21 #include <lightning/jit_private.h>
  22
  23 #define print_chr(value)                fputc(value, print_stream)
  24 #define print_hex(value)                fprintf(print_stream, "0x%lx", value)
  25 #define print_dec(value)                fprintf(print_stream, "%ld", value)
  26 #define print_flt(value)                fprintf(print_stream, "%g", value)
  27 #define print_str(value)                fprintf(print_stream, "%s", value)
  28 #define print_ptr(value)                fprintf(print_stream, "%p", value)
  29 #define print_reg(value)                                                \
  30     do {                                                                \
  31         if ((value) & jit_regno_patch)                                  \
  32             print_chr('?');                                             \
  33         print_str(_rvs[jit_regno(value)].name);                         \
  34     } while (0)
  35 #define print_arg(value)                                                \
  36     do {                                                                \
  37         print_chr('#');                                                 \
  38         if (value)                                                      \
  39             print_dec((value)->v.w);                                    \
  40         else                                                            \
  41             print_chr('?');                                             \
  42     } while (0)
  43
  44 /*
  45  * Initialization
  46  */
  47 #include "jit_names.c"
  48 /*
  49  * Initialization
  50  */
  51 static FILE     *print_stream;
  52
  53
  54 /*
  55  * Implementation
  56  */
  57 void
  58 _jit_print(jit_state_t *_jit)
  59 {
  60     jit_node_t          *node;
  61
  62     if (!print_stream)
  63         print_stream = stderr;
  64
  65     if ((node = _jitc->head)) {
  66         jit_print_node(node);
  67         for (node = node->next; node; node = node->next) {
  68             print_chr('\n');
  69             jit_print_node(node);
  70         }
  71         print_chr('\n');
  72     }
  73 }
  74
  75 void
  76 _jit_print_node(jit_state_t *_jit, jit_node_t *node)
  77 {
  78     jit_block_t         *block;
  79     jit_int32_t          value;
  80     jit_int32_t          offset;
  81
  82     if (node->code == jit_code_label ||
  83         node->code == jit_code_prolog || node->code == jit_code_epilog) {
  84         print_chr('L');
  85         print_dec(node->v.w);
  86         print_chr(':');
  87         block = _jitc->blocks.ptr + node->v.w;
  88         for (offset = 0; offset < _jitc->reglen; offset++) {
  89             if (jit_regset_tstbit(&block->reglive, offset)) {
  90                 print_chr(' ');
  91                 print_reg(offset);
  92             }
  93         }
  94         if (node->code == jit_code_prolog ||
  95             node->code == jit_code_epilog) {
  96             print_str(" /* ");
  97             print_str(code_name[node->code]);
  98             print_str(" */");
  99         }
 100         return;
 101     }
 102     value = jit_classify(node->code) &
 103         (jit_cc_a0_int|jit_cc_a0_flt|jit_cc_a0_dbl|jit_cc_a0_jmp|
 104          jit_cc_a0_reg|jit_cc_a0_rlh|jit_cc_a0_arg|
 105          jit_cc_a1_reg|jit_cc_a1_int|jit_cc_a1_flt|jit_cc_a1_dbl|jit_cc_a1_arg|
 106          jit_cc_a2_reg|jit_cc_a2_int|jit_cc_a2_flt|jit_cc_a2_dbl);
 107     if (!(node->flag & jit_flag_synth) && ((value & jit_cc_a0_jmp) ||
 108                                            node->code == jit_code_finishr ||
 109                                            node->code == jit_code_finishi))
 110         print_str("    ");
 111     else
 112         print_chr('\t');
 113     if (node->flag & jit_flag_synth)
 114         print_str(" \\__ ");
 115     print_str(code_name[node->code]);
 116     switch (node->code) {
 117         r:
 118             print_chr(' ');     print_reg(node->u.w);   return;
 119         w:
 120             print_chr(' ');     print_hex(node->u.w);   return;
 121         f:
 122             print_chr(' ');
 123             if (node->flag & jit_flag_data)
 124                 print_flt(*(jit_float32_t *)node->u.n->u.w);
 125             else
 126                 print_flt(node->u.f);
 127             return;
 128         d:
 129             print_chr(' ');
 130             if (node->flag & jit_flag_data)
 131                 print_flt(*(jit_float64_t *)node->u.n->u.w);
 132             else
 133                 print_flt(node->u.d);
 134             return;
 135         n:
 136             print_chr(' ');
 137             if (!(node->flag & jit_flag_node))
 138                 print_ptr(node->u.p);
 139             else {
 140                 print_chr('L');
 141                 print_dec(node->u.n->v.w);
 142             }
 143             return;
 144         a:
 145             print_chr(' ');     print_arg(node);        return;
 146         r_r:
 147             print_chr(' ');     print_reg(node->u.w);
 148             print_chr(' ');     print_reg(node->v.w);   return;
 149         r_w:
 150             print_chr(' ');     print_reg(node->u.w);
 151             print_chr(' ');     print_hex(node->v.w);   return;
 152         r_f:
 153             print_chr(' ');     print_reg(node->u.w);
 154             print_chr(' ');
 155             if (node->flag & jit_flag_data)
 156                 print_flt(*(jit_float32_t *)node->v.n->u.w);
 157             else
 158                 print_flt(node->v.f);
 159             return;
 160         r_d:
 161             print_chr(' ');     print_reg(node->u.w);
 162             print_chr(' ');
 163             if (node->flag & jit_flag_data)
 164                 print_flt(*(jit_float64_t *)node->v.n->u.w);
 165             else
 166                 print_flt(node->v.d);
 167             return;
 168         r_a:
 169             print_chr(' ');     print_reg(node->u.w);
 170             print_chr(' ');     print_arg(node->v.n);
 171             return;
 172         w_r:
 173             print_chr(' ');     print_hex(node->u.w);
 174             print_chr(' ');     print_reg(node->v.w);   return;
 175         w_w:
 176             print_chr(' ');     print_hex(node->u.w);
 177             print_chr(' ');     print_hex(node->v.w);   return;
 178         w_a:
 179             print_chr(' ');     print_hex(node->u.w);
 180             print_chr(' ');     print_arg(node->v.n);
 181             return;
 182         f_a:
 183             print_chr(' ');
 184             if (node->flag & jit_flag_data)
 185                 print_flt(*(jit_float32_t *)node->u.n->u.w);
 186             else
 187                 print_flt(node->u.f);
 188             print_chr(' ');     print_arg(node->v.n);
 189             return;
 190         d_a:
 191             print_chr(' ');
 192             if (node->flag & jit_flag_data)
 193                 print_flt(*(jit_float64_t *)node->u.n->u.w);
 194             else
 195                 print_flt(node->u.d);
 196             print_chr(' ');     print_arg(node->v.n);
 197             return;
 198         r_r_r:
 199             print_chr(' ');     print_reg(node->u.w);
 200             print_chr(' ');     print_reg(node->v.w);
 201             print_chr(' ');     print_reg(node->w.w);   return;
 202         r_r_w:
 203             print_chr(' ');     print_reg(node->u.w);
 204             print_chr(' ');     print_reg(node->v.w);
 205             print_chr(' ');     print_hex(node->w.w);   return;
 206         q_r_r:
 207             print_str(" (");    print_reg(node->u.q.l);
 208             print_chr(' ');     print_reg(node->u.q.h);
 209             print_str(") ");    print_reg(node->v.w);
 210             print_chr(' ');     print_reg(node->w.w);   return;
 211         q_r_w:
 212             print_str(" (");    print_reg(node->u.q.l);
 213             print_chr(' ');     print_reg(node->u.q.h);
 214             print_str(") ");    print_reg(node->v.w);
 215             print_chr(' ');     print_hex(node->w.w);   return;
 216         r_r_f:
 217             print_chr(' ');     print_reg(node->u.w);
 218             print_chr(' ');     print_reg(node->v.w);
 219             print_chr(' ');
 220             if (node->flag & jit_flag_data)
 221                 print_flt(*(jit_float32_t *)node->w.n->u.w);
 222             else
 223                 print_flt(node->w.f);
 224             return;
 225         r_r_d:
 226             print_chr(' ');     print_reg(node->u.w);
 227             print_chr(' ');     print_reg(node->v.w);
 228             print_chr(' ');
 229             if (node->flag & jit_flag_data)
 230                 print_flt(*(jit_float64_t *)node->w.n->u.w);
 231             else
 232                 print_flt(node->w.d);
 233             return;
 234         w_r_r:
 235             print_chr(' ');     print_hex(node->u.w);
 236             print_chr(' ');     print_reg(node->v.w);
 237             print_chr(' ');     print_reg(node->w.w);   return;
 238         n_r_r:
 239             print_chr(' ');
 240             if (!(node->flag & jit_flag_node))
 241                 print_ptr(node->u.p);
 242             else {
 243                 print_chr('L');
 244                 print_dec(node->u.n->v.w);
 245             }
 246             print_chr(' ');     print_reg(node->v.w);
 247             print_chr(' ');     print_reg(node->w.w);   return;
 248         n_r_w:
 249             print_chr(' ');
 250             if (!(node->flag & jit_flag_node))
 251                 print_ptr(node->u.p);
 252             else {
 253                 print_chr('L');
 254                 print_dec(node->u.n->v.w);
 255             }
 256             print_chr(' ');     print_reg(node->v.w);
 257             print_chr(' ');     print_hex(node->w.w);   return;
 258         n_r_f:
 259             print_chr(' ');
 260             if (!(node->flag & jit_flag_node))
 261                 print_ptr(node->u.p);
 262             else{
 263                 print_chr('L');
 264                 print_dec(node->u.n->v.w);
 265             }
 266             print_chr(' ');     print_reg(node->v.w);
 267             print_chr(' ');
 268             if (node->flag & jit_flag_data)
 269                 print_flt(*(jit_float32_t *)node->w.n->u.w);
 270             else
 271                 print_flt(node->w.f);
 272             return;
 273         n_r_d:
 274             print_chr(' ');
 275             if (!(node->flag & jit_flag_node))
 276                 print_ptr(node->u.p);
 277             else {
 278                 print_chr('L');
 279                 print_dec(node->u.n->v.w);
 280             }
 281             print_chr(' ');     print_reg(node->v.w);
 282             print_chr(' ');
 283             if (node->flag & jit_flag_data)
 284                 print_flt(*(jit_float64_t *)node->w.n->u.w);
 285             else
 286                 print_flt(node->w.d);
 287             return;
 288         case jit_code_name:
 289             print_chr(' ');
 290             if (node->v.p && _jitc->emit)
 291                 print_str(node->v.n->u.p);
 292             break;
 293         case jit_code_note:
 294             print_chr(' ');
 295             if (node->v.p && _jitc->emit)
 296                 print_str(node->v.n->u.p);
 297             if (node->v.p && _jitc->emit && node->w.w)
 298                 print_chr(':');
 299             if (node->w.w)
 300                 print_dec(node->w.w);
 301             break;
 302         case jit_code_data:
 303         case jit_code_label:
 304         case jit_code_ellipsis:
 305         case jit_code_prolog:   case jit_code_epilog:
 306         case jit_code_ret:      case jit_code_prepare:
 307             break;
 308         case jit_code_save:     case jit_code_load:
 309             goto r;
 310         default:
 311             switch (value) {
 312                 case jit_cc_a0_reg:
 313                 case jit_cc_a0_reg|jit_cc_a0_chg:
 314                 case jit_cc_a0_reg|jit_cc_a0_jmp:
 315                     goto r;
 316                 case jit_cc_a0_int:
 317                     goto w;
 318                 case jit_cc_a0_flt:
 319                     goto f;
 320                 case jit_cc_a0_dbl:
 321                     goto d;
 322                 case jit_cc_a0_jmp:
 323                     goto n;
 324                 case jit_cc_a0_int|jit_cc_a0_arg:
 325                     goto a;
 326                 case jit_cc_a0_reg|jit_cc_a1_reg:
 327                     goto r_r;
 328                 case jit_cc_a0_reg|jit_cc_a1_int:
 329                     goto r_w;
 330                 case jit_cc_a0_reg|jit_cc_a1_flt:
 331                     goto r_f;
 332                 case jit_cc_a0_reg|jit_cc_a1_dbl:
 333                     goto r_d;
 334                 case jit_cc_a0_reg|jit_cc_a1_arg:
 335                     goto r_a;
 336                 case jit_cc_a0_int|jit_cc_a1_reg:
 337                     goto w_r;
 338                 case jit_cc_a0_int|jit_cc_a1_int:
 339                     goto w_w;
 340                 case jit_cc_a0_int|jit_cc_a1_arg:
 341                     goto w_a;
 342                 case jit_cc_a0_flt|jit_cc_a1_arg:
 343                     goto f_a;
 344                 case jit_cc_a0_dbl|jit_cc_a1_arg:
 345                     goto d_a;
 346                 case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_reg:
 347                     goto r_r_r;
 348                 case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_int:
 349                     goto r_r_w;
 350                 case jit_cc_a0_reg|jit_cc_a0_rlh|
 351                      jit_cc_a1_reg|jit_cc_a2_reg:
 352                     goto q_r_r;
 353                 case jit_cc_a0_reg|jit_cc_a0_rlh|
 354                      jit_cc_a1_reg|jit_cc_a2_int:
 355                     goto q_r_w;
 356                 case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_flt:
 357                     goto r_r_f;
 358                 case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_dbl:
 359                     goto r_r_d;
 360                 case jit_cc_a0_int|jit_cc_a1_reg|jit_cc_a2_reg:
 361                     goto w_r_r;
 362                 case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_reg:
 363                     goto n_r_r;
 364                 case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_int:
 365                     goto n_r_w;
 366                 case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_flt:
 367                     goto n_r_f;
 368                 case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_dbl:
 369                     goto n_r_d;
 370                 default:
 371                     abort();
 372             }
 373             break;
 374     }
 375 }