gdb/ax-general.c

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