gdb/ax-general.c

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