gdb/ax-general.c

   1 /* Functions for manipulating expressions designed to be executed on the agent
   2    Copyright (C) 1998-2024 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Despite what the above comment says about this file being part of
  20    GDB, we would like to keep these functions free of GDB
  21    dependencies, since we want to be able to use them in contexts
  22    outside of GDB (test suites, the stub, etc.)  */
  23
  24 #include "ax.h"
  25 #include "gdbarch.h"
  26
  27 #include "value.h"
  28 #include "user-regs.h"
  29
  30 static void append_const (struct agent_expr *x, LONGEST val, int n);
  31
  32 static LONGEST read_const (struct agent_expr *x, int o, int n);
  33
  34 static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
  35 \f
  36 /* Functions for building expressions.  */
  37
  38 /* Append the low N bytes of VAL as an N-byte integer to the
  39    expression X, in big-endian order.  */
  40 static void
  41 append_const (struct agent_expr *x, LONGEST val, int n)
  42 {
  43   size_t len = x->buf.size ();
  44   x->buf.resize (len + n);
  45   for (int i = n - 1; i >= 0; i--)
  46     {
  47       x->buf[len + i] = val & 0xff;
  48       val >>= 8;
  49     }
  50 }
  51
  52
  53 /* Extract an N-byte big-endian unsigned integer from expression X at
  54    offset O.  */
  55 static LONGEST
  56 read_const (struct agent_expr *x, int o, int n)
  57 {
  58   int i;
  59   LONGEST accum = 0;
  60
  61   /* Make sure we're not reading off the end of the expression.  */
  62   if (o + n > x->buf.size ())
  63     error (_("GDB bug: ax-general.c (read_const): incomplete constant"));
  64
  65   for (i = 0; i < n; i++)
  66     accum = (accum << 8) | x->buf[o + i];
  67
  68   return accum;
  69 }
  70
  71 /* See ax.h.  */
  72
  73 void
  74 ax_raw_byte (struct agent_expr *x, gdb_byte byte)
  75 {
  76   x->buf.push_back (byte);
  77 }
  78
  79 /* Append a simple operator OP to EXPR.  */
  80 void
  81 ax_simple (struct agent_expr *x, enum agent_op op)
  82 {
  83   ax_raw_byte (x, op);
  84 }
  85
  86 /* Append a pick operator to EXPR.  DEPTH is the stack item to pick,
  87    with 0 being top of stack.  */
  88
  89 void
  90 ax_pick (struct agent_expr *x, int depth)
  91 {
  92   if (depth < 0 || depth > 255)
  93     error (_("GDB bug: ax-general.c (ax_pick): stack depth out of range"));
  94   ax_simple (x, aop_pick);
  95   append_const (x, 1, depth);
  96 }
  97
  98
  99 /* Append a sign-extension or zero-extension instruction to EXPR, to
 100    extend an N-bit value.  */
 101 static void
 102 generic_ext (struct agent_expr *x, enum agent_op op, int n)
 103 {
 104   /* N must fit in a byte.  */
 105   if (n < 0 || n > 255)
 106     error (_("GDB bug: ax-general.c (generic_ext): bit count out of range"));
 107   /* That had better be enough range.  */
 108   if (sizeof (LONGEST) * 8 > 255)
 109     error (_("GDB bug: ax-general.c (generic_ext): "
 110              "opcode has inadequate range"));
 111
 112   x->buf.push_back (op);
 113   x->buf.push_back (n);
 114 }
 115
 116
 117 /* Append a sign-extension instruction to EXPR, to extend an N-bit value.  */
 118 void
 119 ax_ext (struct agent_expr *x, int n)
 120 {
 121   generic_ext (x, aop_ext, n);
 122 }
 123
 124
 125 /* Append a zero-extension instruction to EXPR, to extend an N-bit value.  */
 126 void
 127 ax_zero_ext (struct agent_expr *x, int n)
 128 {
 129   generic_ext (x, aop_zero_ext, n);
 130 }
 131
 132
 133 /* Append a trace_quick instruction to EXPR, to record N bytes.  */
 134 void
 135 ax_trace_quick (struct agent_expr *x, int n)
 136 {
 137   /* N must fit in a byte.  */
 138   if (n < 0 || n > 255)
 139     error (_("GDB bug: ax-general.c (ax_trace_quick): "
 140              "size out of range for trace_quick"));
 141
 142   x->buf.push_back (aop_trace_quick);
 143   x->buf.push_back (n);
 144 }
 145
 146
 147 /* Append a goto op to EXPR.  OP is the actual op (must be aop_goto or
 148    aop_if_goto).  We assume we don't know the target offset yet,
 149    because it's probably a forward branch, so we leave space in EXPR
 150    for the target, and return the offset in EXPR of that space, so we
 151    can backpatch it once we do know the target offset.  Use ax_label
 152    to do the backpatching.  */
 153 int
 154 ax_goto (struct agent_expr *x, enum agent_op op)
 155 {
 156   x->buf.push_back (op);
 157   x->buf.push_back (0xff);
 158   x->buf.push_back (0xff);
 159   return x->buf.size () - 2;
 160 }
 161
 162 /* Suppose a given call to ax_goto returns some value PATCH.  When you
 163    know the offset TARGET that goto should jump to, call
 164    ax_label (EXPR, PATCH, TARGET)
 165    to patch TARGET into the ax_goto instruction.  */
 166 void
 167 ax_label (struct agent_expr *x, int patch, int target)
 168 {
 169   /* Make sure the value is in range.  Don't accept 0xffff as an
 170      offset; that's our magic sentinel value for unpatched branches.  */
 171   if (target < 0 || target >= 0xffff)
 172     error (_("GDB bug: ax-general.c (ax_label): label target out of range"));
 173
 174   x->buf[patch] = (target >> 8) & 0xff;
 175   x->buf[patch + 1] = target & 0xff;
 176 }
 177
 178
 179 /* Assemble code to push a constant on the stack.  */
 180 void
 181 ax_const_l (struct agent_expr *x, LONGEST l)
 182 {
 183   static enum agent_op ops[]
 184   =
 185   {aop_const8, aop_const16, aop_const32, aop_const64};
 186   int size;
 187   int op;
 188
 189   /* How big is the number?  'op' keeps track of which opcode to use.
 190      Notice that we don't really care whether the original number was
 191      signed or unsigned; we always reproduce the value exactly, and
 192      use the shortest representation.  */
 193   for (op = 0, size = 8; size < 64; size *= 2, op++)
 194     {
 195       LONGEST lim = ((LONGEST) 1) << (size - 1);
 196
 197       if (-lim <= l && l <= lim - 1)
 198         break;
 199     }
 200
 201   /* Emit the right opcode...  */
 202   ax_simple (x, ops[op]);
 203
 204   /* Emit the low SIZE bytes as an unsigned number.  We know that
 205      sign-extending this will yield l.  */
 206   append_const (x, l, size / 8);
 207
 208   /* Now, if it was negative, and not full-sized, sign-extend it.  */
 209   if (l < 0 && size < 64)
 210     ax_ext (x, size);
 211 }
 212
 213
 214 void
 215 ax_const_d (struct agent_expr *x, LONGEST d)
 216 {
 217   /* FIXME: floating-point support not present yet.  */
 218   error (_("GDB bug: ax-general.c (ax_const_d): "
 219            "floating point not supported yet"));
 220 }
 221
 222
 223 /* Assemble code to push the value of register number REG on the
 224    stack.  */
 225 void
 226 ax_reg (struct agent_expr *x, int reg)
 227 {
 228   if (reg >= gdbarch_num_regs (x->gdbarch))
 229     {
 230       /* This is a pseudo-register.  */
 231       if (!gdbarch_ax_pseudo_register_push_stack_p (x->gdbarch))
 232         error (_("'%s' is a pseudo-register; "
 233                  "GDB cannot yet trace its contents."),
 234                user_reg_map_regnum_to_name (x->gdbarch, reg));
 235       if (gdbarch_ax_pseudo_register_push_stack (x->gdbarch, x, reg))
 236         error (_("Trace '%s' failed."),
 237                user_reg_map_regnum_to_name (x->gdbarch, reg));
 238     }
 239   else
 240     {
 241       /* Get the remote register number.  */
 242       reg = gdbarch_remote_register_number (x->gdbarch, reg);
 243
 244       /* Make sure the register number is in range.  */
 245       if (reg < 0 || reg > 0xffff)
 246         error (_("GDB bug: ax-general.c (ax_reg): "
 247                  "register number out of range"));
 248       x->buf.push_back (aop_reg);
 249       x->buf.push_back ((reg >> 8) & 0xff);
 250       x->buf.push_back ((reg) & 0xff);
 251     }
 252 }
 253
 254 /* Assemble code to operate on a trace state variable.  */
 255
 256 void
 257 ax_tsv (struct agent_expr *x, enum agent_op op, int num)
 258 {
 259   /* Make sure the tsv number is in range.  */
 260   if (num < 0 || num > 0xffff)
 261     internal_error (_("ax-general.c (ax_tsv): variable "
 262                       "number is %d, out of range"), num);
 263
 264   x->buf.push_back (op);
 265   x->buf.push_back ((num >> 8) & 0xff);
 266   x->buf.push_back ((num) & 0xff);
 267 }
 268
 269 /* Append a string to the expression.  Note that the string is going
 270    into the bytecodes directly, not on the stack.  As a precaution,
 271    include both length as prefix, and terminate with a NUL.  (The NUL
 272    is counted in the length.)  */
 273
 274 void
 275 ax_string (struct agent_expr *x, const char *str, int slen)
 276 {
 277   int i;
 278
 279   /* Make sure the string length is reasonable.  */
 280   if (slen < 0 || slen > 0xffff)
 281     internal_error (_("ax-general.c (ax_string): string "
 282                       "length is %d, out of allowed range"), slen);
 283
 284   x->buf.push_back (((slen + 1) >> 8) & 0xff);
 285   x->buf.push_back ((slen + 1) & 0xff);
 286   for (i = 0; i < slen; ++i)
 287     x->buf.push_back (str[i]);
 288   x->buf.push_back ('\0');
 289 }
 290 \f
 291
 292
 293 /* Functions for disassembling agent expressions, and otherwise
 294    debugging the expression compiler.  */
 295
 296 /* An entry in the opcode map.  */
 297 struct aop_map
 298   {
 299
 300     /* The name of the opcode.  Null means that this entry is not a
 301        valid opcode --- a hole in the opcode space.  */
 302     const char *name;
 303
 304     /* All opcodes take no operands from the bytecode stream, or take
 305        unsigned integers of various sizes.  If this is a positive number
 306        n, then the opcode is followed by an n-byte operand, which should
 307        be printed as an unsigned integer.  If this is zero, then the
 308        opcode takes no operands from the bytecode stream.
 309
 310        If we get more complicated opcodes in the future, don't add other
 311        magic values of this; that's a crock.  Add an `enum encoding'
 312        field to this, or something like that.  */
 313     int op_size;
 314
 315     /* The size of the data operated upon, in bits, for bytecodes that
 316        care about that (ref and const).  Zero for all others.  */
 317     int data_size;
 318
 319     /* Number of stack elements consumed, and number produced.  */
 320     int consumed, produced;
 321   };
 322
 323 /* Map of the bytecodes, indexed by bytecode number.  */
 324
 325 static struct aop_map aop_map[] =
 326 {
 327   {0, 0, 0, 0, 0}
 328 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
 329   , { # NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED }
 330 #include "gdbsupport/ax.def"
 331 #undef DEFOP
 332 };
 333
 334
 335 /* Disassemble the expression EXPR, writing to F.  */
 336 void
 337 ax_print (struct ui_file *f, struct agent_expr *x)
 338 {
 339   int i;
 340
 341   gdb_printf (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
 342   gdb_printf (f, _("Reg mask:"));
 343   for (i = 0; i < x->reg_mask.size (); ++i)
 344     {
 345       if ((i % 8) == 0)
 346         gdb_printf (f, " ");
 347       gdb_printf (f, _("%d"), (int) x->reg_mask[i]);
 348     }
 349   gdb_printf (f, _("\n"));
 350
 351   for (i = 0; i < x->buf.size ();)
 352     {
 353       enum agent_op op = (enum agent_op) x->buf[i];
 354
 355       if (op >= ARRAY_SIZE (aop_map) || aop_map[op].name == nullptr)
 356         {
 357           gdb_printf (f, _("%3d  <bad opcode %02x>\n"), i, op);
 358           i++;
 359           continue;
 360         }
 361       if (i + 1 + aop_map[op].op_size > x->buf.size ())
 362         {
 363           gdb_printf (f, _("%3d  <incomplete opcode %s>\n"),
 364                       i, aop_map[op].name);
 365           break;
 366         }
 367
 368       gdb_printf (f, "%3d  %s", i, aop_map[op].name);
 369       if (aop_map[op].op_size > 0)
 370         {
 371           gdb_puts (" ", f);
 372
 373           print_longest (f, 'd', 0,
 374                          read_const (x, i + 1, aop_map[op].op_size));
 375         }
 376       /* Handle the complicated printf arguments specially.  */
 377       else if (op == aop_printf)
 378         {
 379           int slen, nargs;
 380
 381           i++;
 382           nargs = x->buf[i++];
 383           slen = x->buf[i++];
 384           slen = slen * 256 + x->buf[i++];
 385           gdb_printf (f, _(" \"%s\", %d args"),
 386                       &(x->buf[i]), nargs);
 387           i += slen - 1;
 388         }
 389       gdb_printf (f, "\n");
 390       i += 1 + aop_map[op].op_size;
 391     }
 392 }
 393
 394 /* Add register REG to the register mask for expression AX.  */
 395 void
 396 ax_reg_mask (struct agent_expr *ax, int reg)
 397 {
 398   if (reg >= gdbarch_num_regs (ax->gdbarch))
 399     {
 400       /* This is a pseudo-register.  */
 401       if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch))
 402         error (_("'%s' is a pseudo-register; "
 403                  "GDB cannot yet trace its contents."),
 404                user_reg_map_regnum_to_name (ax->gdbarch, reg));
 405       if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg))
 406         error (_("Trace '%s' failed."),
 407                user_reg_map_regnum_to_name (ax->gdbarch, reg));
 408     }
 409   else
 410     {
 411       /* Get the remote register number.  */
 412       reg = gdbarch_remote_register_number (ax->gdbarch, reg);
 413
 414       /* Grow the bit mask if necessary.  */
 415       if (reg >= ax->reg_mask.size ())
 416         ax->reg_mask.resize (reg + 1);
 417
 418       ax->reg_mask[reg] = true;
 419     }
 420 }
 421
 422 /* Given an agent expression AX, fill in requirements and other descriptive
 423    bits.  */
 424 void
 425 ax_reqs (struct agent_expr *ax)
 426 {
 427   int i;
 428   int height;
 429
 430   /* Jump target table.  targets[i] is non-zero iff we have found a
 431      jump to offset i.  */
 432   char *targets = (char *) alloca (ax->buf.size () * sizeof (targets[0]));
 433
 434   /* Instruction boundary table.  boundary[i] is non-zero iff our scan
 435      has reached an instruction starting at offset i.  */
 436   char *boundary = (char *) alloca (ax->buf.size () * sizeof (boundary[0]));
 437
 438   /* Stack height record.  If either targets[i] or boundary[i] is
 439      non-zero, heights[i] is the height the stack should have before
 440      executing the bytecode at that point.  */
 441   int *heights = (int *) alloca (ax->buf.size () * sizeof (heights[0]));
 442
 443   /* Pointer to a description of the present op.  */
 444   struct aop_map *op;
 445
 446   memset (targets, 0, ax->buf.size () * sizeof (targets[0]));
 447   memset (boundary, 0, ax->buf.size () * sizeof (boundary[0]));
 448
 449   ax->max_height = ax->min_height = height = 0;
 450   ax->flaw = agent_flaw_none;
 451   ax->max_data_size = 0;
 452
 453   for (i = 0; i < ax->buf.size (); i += 1 + op->op_size)
 454     {
 455       if (ax->buf[i] >= ARRAY_SIZE (aop_map))
 456         {
 457           ax->flaw = agent_flaw_bad_instruction;
 458           return;
 459         }
 460
 461       op = &aop_map[ax->buf[i]];
 462
 463       if (!op->name)
 464         {
 465           ax->flaw = agent_flaw_bad_instruction;
 466           return;
 467         }
 468
 469       if (i + 1 + op->op_size > ax->buf.size ())
 470         {
 471           ax->flaw = agent_flaw_incomplete_instruction;
 472           return;
 473         }
 474
 475       /* If this instruction is a forward jump target, does the
 476          current stack height match the stack height at the jump
 477          source?  */
 478       if (targets[i] && (heights[i] != height))
 479         {
 480           ax->flaw = agent_flaw_height_mismatch;
 481           return;
 482         }
 483
 484       boundary[i] = 1;
 485       heights[i] = height;
 486
 487       height -= op->consumed;
 488       if (height < ax->min_height)
 489         ax->min_height = height;
 490       height += op->produced;
 491       if (height > ax->max_height)
 492         ax->max_height = height;
 493
 494       if (op->data_size > ax->max_data_size)
 495         ax->max_data_size = op->data_size;
 496
 497       /* For jump instructions, check that the target is a valid
 498          offset.  If it is, record the fact that that location is a
 499          jump target, and record the height we expect there.  */
 500       if (aop_goto == op - aop_map
 501           || aop_if_goto == op - aop_map)
 502         {
 503           int target = read_const (ax, i + 1, 2);
 504           if (target < 0 || target >= ax->buf.size ())
 505             {
 506               ax->flaw = agent_flaw_bad_jump;
 507               return;
 508             }
 509
 510           /* Do we have any information about what the stack height
 511              should be at the target?  */
 512           if (targets[target] || boundary[target])
 513             {
 514               if (heights[target] != height)
 515                 {
 516                   ax->flaw = agent_flaw_height_mismatch;
 517                   return;
 518                 }
 519             }
 520
 521           /* Record the target, along with the stack height we expect.  */
 522           targets[target] = 1;
 523           heights[target] = height;
 524         }
 525
 526       /* For unconditional jumps with a successor, check that the
 527          successor is a target, and pick up its stack height.  */
 528       if (aop_goto == op - aop_map
 529           && i + 3 < ax->buf.size ())
 530         {
 531           if (!targets[i + 3])
 532             {
 533               ax->flaw = agent_flaw_hole;
 534               return;
 535             }
 536
 537           height = heights[i + 3];
 538         }
 539
 540       /* For reg instructions, record the register in the bit mask.  */
 541       if (aop_reg == op - aop_map)
 542         {
 543           int reg = read_const (ax, i + 1, 2);
 544
 545           ax_reg_mask (ax, reg);
 546         }
 547     }
 548
 549   /* Check that all the targets are on boundaries.  */
 550   for (i = 0; i < ax->buf.size (); i++)
 551     if (targets[i] && !boundary[i])
 552       {
 553         ax->flaw = agent_flaw_bad_jump;
 554         return;
 555       }
 556
 557   ax->final_height = height;
 558 }