gdb/ax-general.c

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