gdb/ax-general.c

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