gdb/ax-general.c

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