gdb/ax-general.c

   1 /* Functions for manipulating expressions designed to be executed on the agent
   2    Copyright (C) 1998, 1999, 2000, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Despite what the above comment says about this file being part of
  21    GDB, we would like to keep these functions free of GDB
  22    dependencies, since we want to be able to use them in contexts
  23    outside of GDB (test suites, the stub, etc.)  */
  24
  25 #include "defs.h"
  26 #include "ax.h"
  27
  28 #include "value.h"
  29 #include "gdb_string.h"
  30
  31 #include "user-regs.h"
  32
  33 static void grow_expr (struct agent_expr *x, int n);
  34
  35 static void append_const (struct agent_expr *x, LONGEST val, int n);
  36
  37 static LONGEST read_const (struct agent_expr *x, int o, int n);
  38
  39 static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
  40 \f
  41 /* Functions for building expressions.  */
  42
  43 /* Allocate a new, empty agent expression.  */
  44 struct agent_expr *
  45 new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope)
  46 {
  47   struct agent_expr *x = xmalloc (sizeof (*x));
  48
  49   x->len = 0;
  50   x->size = 1;                  /* Change this to a larger value once
  51                                    reallocation code is tested.  */
  52   x->buf = xmalloc (x->size);
  53
  54   x->gdbarch = gdbarch;
  55   x->scope = scope;
  56
  57   /* Bit vector for registers used.  */
  58   x->reg_mask_len = 1;
  59   x->reg_mask = xmalloc (x->reg_mask_len * sizeof (x->reg_mask[0]));
  60   memset (x->reg_mask, 0, x->reg_mask_len * sizeof (x->reg_mask[0]));
  61
  62   return x;
  63 }
  64
  65 /* Free a agent expression.  */
  66 void
  67 free_agent_expr (struct agent_expr *x)
  68 {
  69   xfree (x->buf);
  70   xfree (x->reg_mask);
  71   xfree (x);
  72 }
  73
  74 static void
  75 do_free_agent_expr_cleanup (void *x)
  76 {
  77   free_agent_expr (x);
  78 }
  79
  80 struct cleanup *
  81 make_cleanup_free_agent_expr (struct agent_expr *x)
  82 {
  83   return make_cleanup (do_free_agent_expr_cleanup, x);
  84 }
  85
  86
  87 /* Make sure that X has room for at least N more bytes.  This doesn't
  88    affect the length, just the allocated size.  */
  89 static void
  90 grow_expr (struct agent_expr *x, int n)
  91 {
  92   if (x->len + n > x->size)
  93     {
  94       x->size *= 2;
  95       if (x->size < x->len + n)
  96         x->size = x->len + n + 10;
  97       x->buf = xrealloc (x->buf, x->size);
  98     }
  99 }
 100
 101
 102 /* Append the low N bytes of VAL as an N-byte integer to the
 103    expression X, in big-endian order.  */
 104 static void
 105 append_const (struct agent_expr *x, LONGEST val, int n)
 106 {
 107   int i;
 108
 109   grow_expr (x, n);
 110   for (i = n - 1; i >= 0; i--)
 111     {
 112       x->buf[x->len + i] = val & 0xff;
 113       val >>= 8;
 114     }
 115   x->len += n;
 116 }
 117
 118
 119 /* Extract an N-byte big-endian unsigned integer from expression X at
 120    offset O.  */
 121 static LONGEST
 122 read_const (struct agent_expr *x, int o, int n)
 123 {
 124   int i;
 125   LONGEST accum = 0;
 126
 127   /* Make sure we're not reading off the end of the expression.  */
 128   if (o + n > x->len)
 129     error (_("GDB bug: ax-general.c (read_const): incomplete constant"));
 130
 131   for (i = 0; i < n; i++)
 132     accum = (accum << 8) | x->buf[o + i];
 133
 134   return accum;
 135 }
 136
 137
 138 /* Append a simple operator OP to EXPR.  */
 139 void
 140 ax_simple (struct agent_expr *x, enum agent_op op)
 141 {
 142   grow_expr (x, 1);
 143   x->buf[x->len++] = op;
 144 }
 145
 146 /* Append a pick operator to EXPR.  DEPTH is the stack item to pick,
 147    with 0 being top of stack.  */
 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 \f
 334
 335
 336 /* Functions for disassembling agent expressions, and otherwise
 337    debugging the expression compiler.  */
 338
 339 struct aop_map aop_map[] =
 340 {
 341   {0, 0, 0, 0, 0}
 342 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
 343   , { # NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED }
 344 #include "ax.def"
 345 #undef DEFOP
 346 };
 347
 348
 349 /* Disassemble the expression EXPR, writing to F.  */
 350 void
 351 ax_print (struct ui_file *f, struct agent_expr *x)
 352 {
 353   int i;
 354   int is_float = 0;
 355
 356   fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
 357   fprintf_filtered (f, _("Reg mask:"));
 358   for (i = 0; i < x->reg_mask_len; ++i)
 359     fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
 360   fprintf_filtered (f, _("\n"));
 361
 362   /* Check the size of the name array against the number of entries in
 363      the enum, to catch additions that people didn't sync.  */
 364   if ((sizeof (aop_map) / sizeof (aop_map[0]))
 365       != aop_last)
 366     error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
 367
 368   for (i = 0; i < x->len;)
 369     {
 370       enum agent_op op = x->buf[i];
 371
 372       if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
 373           || !aop_map[op].name)
 374         {
 375           fprintf_filtered (f, _("%3d  <bad opcode %02x>\n"), i, op);
 376           i++;
 377           continue;
 378         }
 379       if (i + 1 + aop_map[op].op_size > x->len)
 380         {
 381           fprintf_filtered (f, _("%3d  <incomplete opcode %s>\n"),
 382                             i, aop_map[op].name);
 383           break;
 384         }
 385
 386       fprintf_filtered (f, "%3d  %s", i, aop_map[op].name);
 387       if (aop_map[op].op_size > 0)
 388         {
 389           fputs_filtered (" ", f);
 390
 391           print_longest (f, 'd', 0,
 392                          read_const (x, i + 1, aop_map[op].op_size));
 393         }
 394       fprintf_filtered (f, "\n");
 395       i += 1 + aop_map[op].op_size;
 396
 397       is_float = (op == aop_float);
 398     }
 399 }
 400
 401 /* Add register REG to the register mask for expression AX.  */
 402 void
 403 ax_reg_mask (struct agent_expr *ax, int reg)
 404 {
 405   if (reg >= gdbarch_num_regs (ax->gdbarch))
 406     {
 407       /* This is a pseudo-register.  */
 408       if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch))
 409         error (_("'%s' is a pseudo-register; "
 410                  "GDB cannot yet trace its contents."),
 411                user_reg_map_regnum_to_name (ax->gdbarch, reg));
 412       if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg))
 413         error (_("Trace '%s' failed."),
 414                user_reg_map_regnum_to_name (ax->gdbarch, reg));
 415     }
 416   else
 417     {
 418       int byte = reg / 8;
 419
 420       /* Grow the bit mask if necessary.  */
 421       if (byte >= ax->reg_mask_len)
 422         {
 423           /* It's not appropriate to double here.  This isn't a
 424              string buffer.  */
 425           int new_len = byte + 1;
 426           unsigned char *new_reg_mask = xrealloc (ax->reg_mask,
 427                                                   new_len
 428                                                   * sizeof (ax->reg_mask[0]));
 429           memset (new_reg_mask + ax->reg_mask_len, 0,
 430                   (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0]));
 431           ax->reg_mask_len = new_len;
 432           ax->reg_mask = new_reg_mask;
 433         }
 434
 435       ax->reg_mask[byte] |= 1 << (reg % 8);
 436     }
 437 }
 438
 439 /* Given an agent expression AX, fill in requirements and other descriptive
 440    bits.  */
 441 void
 442 ax_reqs (struct agent_expr *ax)
 443 {
 444   int i;
 445   int height;
 446
 447   /* Jump target table.  targets[i] is non-zero iff we have found a
 448      jump to offset i.  */
 449   char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
 450
 451   /* Instruction boundary table.  boundary[i] is non-zero iff our scan
 452      has reached an instruction starting at offset i.  */
 453   char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
 454
 455   /* Stack height record.  If either targets[i] or boundary[i] is
 456      non-zero, heights[i] is the height the stack should have before
 457      executing the bytecode at that point.  */
 458   int *heights = (int *) alloca (ax->len * sizeof (heights[0]));
 459
 460   /* Pointer to a description of the present op.  */
 461   struct aop_map *op;
 462
 463   memset (targets, 0, ax->len * sizeof (targets[0]));
 464   memset (boundary, 0, ax->len * sizeof (boundary[0]));
 465
 466   ax->max_height = ax->min_height = height = 0;
 467   ax->flaw = agent_flaw_none;
 468   ax->max_data_size = 0;
 469
 470   for (i = 0; i < ax->len; i += 1 + op->op_size)
 471     {
 472       if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
 473         {
 474           ax->flaw = agent_flaw_bad_instruction;
 475           return;
 476         }
 477
 478       op = &aop_map[ax->buf[i]];
 479
 480       if (!op->name)
 481         {
 482           ax->flaw = agent_flaw_bad_instruction;
 483           return;
 484         }
 485
 486       if (i + 1 + op->op_size > ax->len)
 487         {
 488           ax->flaw = agent_flaw_incomplete_instruction;
 489           return;
 490         }
 491
 492       /* If this instruction is a forward jump target, does the
 493          current stack height match the stack height at the jump
 494          source?  */
 495       if (targets[i] && (heights[i] != height))
 496         {
 497           ax->flaw = agent_flaw_height_mismatch;
 498           return;
 499         }
 500
 501       boundary[i] = 1;
 502       heights[i] = height;
 503
 504       height -= op->consumed;
 505       if (height < ax->min_height)
 506         ax->min_height = height;
 507       height += op->produced;
 508       if (height > ax->max_height)
 509         ax->max_height = height;
 510
 511       if (op->data_size > ax->max_data_size)
 512         ax->max_data_size = op->data_size;
 513
 514       /* For jump instructions, check that the target is a valid
 515          offset.  If it is, record the fact that that location is a
 516          jump target, and record the height we expect there.  */
 517       if (aop_goto == op - aop_map
 518           || aop_if_goto == op - aop_map)
 519         {
 520           int target = read_const (ax, i + 1, 2);
 521           if (target < 0 || target >= ax->len)
 522             {
 523               ax->flaw = agent_flaw_bad_jump;
 524               return;
 525             }
 526
 527           /* Do we have any information about what the stack height
 528              should be at the target?  */
 529           if (targets[target] || boundary[target])
 530             {
 531               if (heights[target] != height)
 532                 {
 533                   ax->flaw = agent_flaw_height_mismatch;
 534                   return;
 535                 }
 536             }
 537
 538           /* Record the target, along with the stack height we expect.  */
 539           targets[target] = 1;
 540           heights[target] = height;
 541         }
 542
 543       /* For unconditional jumps with a successor, check that the
 544          successor is a target, and pick up its stack height.  */
 545       if (aop_goto == op - aop_map
 546           && i + 3 < ax->len)
 547         {
 548           if (!targets[i + 3])
 549             {
 550               ax->flaw = agent_flaw_hole;
 551               return;
 552             }
 553
 554           height = heights[i + 3];
 555         }
 556
 557       /* For reg instructions, record the register in the bit mask.  */
 558       if (aop_reg == op - aop_map)
 559         {
 560           int reg = read_const (ax, i + 1, 2);
 561
 562           ax_reg_mask (ax, reg);
 563         }
 564     }
 565
 566   /* Check that all the targets are on boundaries.  */
 567   for (i = 0; i < ax->len; i++)
 568     if (targets[i] && !boundary[i])
 569       {
 570         ax->flaw = agent_flaw_bad_jump;
 571         return;
 572       }
 573
 574   ax->final_height = height;
 575 }