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   {"float", 0, 0, 0, 0},        /* 0x01 */
 343   {"add", 0, 0, 2, 1},          /* 0x02 */
 344   {"sub", 0, 0, 2, 1},          /* 0x03 */
 345   {"mul", 0, 0, 2, 1},          /* 0x04 */
 346   {"div_signed", 0, 0, 2, 1},   /* 0x05 */
 347   {"div_unsigned", 0, 0, 2, 1}, /* 0x06 */
 348   {"rem_signed", 0, 0, 2, 1},   /* 0x07 */
 349   {"rem_unsigned", 0, 0, 2, 1}, /* 0x08 */
 350   {"lsh", 0, 0, 2, 1},          /* 0x09 */
 351   {"rsh_signed", 0, 0, 2, 1},   /* 0x0a */
 352   {"rsh_unsigned", 0, 0, 2, 1}, /* 0x0b */
 353   {"trace", 0, 0, 2, 0},        /* 0x0c */
 354   {"trace_quick", 1, 0, 1, 1},  /* 0x0d */
 355   {"log_not", 0, 0, 1, 1},      /* 0x0e */
 356   {"bit_and", 0, 0, 2, 1},      /* 0x0f */
 357   {"bit_or", 0, 0, 2, 1},       /* 0x10 */
 358   {"bit_xor", 0, 0, 2, 1},      /* 0x11 */
 359   {"bit_not", 0, 0, 1, 1},      /* 0x12 */
 360   {"equal", 0, 0, 2, 1},        /* 0x13 */
 361   {"less_signed", 0, 0, 2, 1},  /* 0x14 */
 362   {"less_unsigned", 0, 0, 2, 1},        /* 0x15 */
 363   {"ext", 1, 0, 1, 1},          /* 0x16 */
 364   {"ref8", 0, 8, 1, 1},         /* 0x17 */
 365   {"ref16", 0, 16, 1, 1},       /* 0x18 */
 366   {"ref32", 0, 32, 1, 1},       /* 0x19 */
 367   {"ref64", 0, 64, 1, 1},       /* 0x1a */
 368   {"ref_float", 0, 0, 1, 1},    /* 0x1b */
 369   {"ref_double", 0, 0, 1, 1},   /* 0x1c */
 370   {"ref_long_double", 0, 0, 1, 1},      /* 0x1d */
 371   {"l_to_d", 0, 0, 1, 1},       /* 0x1e */
 372   {"d_to_l", 0, 0, 1, 1},       /* 0x1f */
 373   {"if_goto", 2, 0, 1, 0},      /* 0x20 */
 374   {"goto", 2, 0, 0, 0},         /* 0x21 */
 375   {"const8", 1, 8, 0, 1},       /* 0x22 */
 376   {"const16", 2, 16, 0, 1},     /* 0x23 */
 377   {"const32", 4, 32, 0, 1},     /* 0x24 */
 378   {"const64", 8, 64, 0, 1},     /* 0x25 */
 379   {"reg", 2, 0, 0, 1},          /* 0x26 */
 380   {"end", 0, 0, 0, 0},          /* 0x27 */
 381   {"dup", 0, 0, 1, 2},          /* 0x28 */
 382   {"pop", 0, 0, 1, 0},          /* 0x29 */
 383   {"zero_ext", 1, 0, 1, 1},     /* 0x2a */
 384   {"swap", 0, 0, 2, 2},         /* 0x2b */
 385   {"getv", 2, 0, 0, 1},         /* 0x2c */
 386   {"setv", 2, 0, 0, 1},         /* 0x2d */
 387   {"tracev", 2, 0, 0, 1},       /* 0x2e */
 388   {0, 0, 0, 0, 0},              /* 0x2f */
 389   {"trace16", 2, 0, 1, 1},      /* 0x30 */
 390   {0, 0, 0, 0, 0},              /* 0x31 */
 391   {"pick", 1, 0, 0, 1},         /* 0x32 */
 392   {"rot", 0, 0, 3, 3},          /* 0x33 */
 393 };
 394
 395
 396 /* Disassemble the expression EXPR, writing to F.  */
 397 void
 398 ax_print (struct ui_file *f, struct agent_expr *x)
 399 {
 400   int i;
 401   int is_float = 0;
 402
 403   fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
 404   fprintf_filtered (f, _("Reg mask:"));
 405   for (i = 0; i < x->reg_mask_len; ++i)
 406     fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
 407   fprintf_filtered (f, _("\n"));
 408
 409   /* Check the size of the name array against the number of entries in
 410      the enum, to catch additions that people didn't sync.  */
 411   if ((sizeof (aop_map) / sizeof (aop_map[0]))
 412       != aop_last)
 413     error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
 414
 415   for (i = 0; i < x->len;)
 416     {
 417       enum agent_op op = x->buf[i];
 418
 419       if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
 420           || !aop_map[op].name)
 421         {
 422           fprintf_filtered (f, _("%3d  <bad opcode %02x>\n"), i, op);
 423           i++;
 424           continue;
 425         }
 426       if (i + 1 + aop_map[op].op_size > x->len)
 427         {
 428           fprintf_filtered (f, _("%3d  <incomplete opcode %s>\n"),
 429                             i, aop_map[op].name);
 430           break;
 431         }
 432
 433       fprintf_filtered (f, "%3d  %s", i, aop_map[op].name);
 434       if (aop_map[op].op_size > 0)
 435         {
 436           fputs_filtered (" ", f);
 437
 438           print_longest (f, 'd', 0,
 439                          read_const (x, i + 1, aop_map[op].op_size));
 440         }
 441       fprintf_filtered (f, "\n");
 442       i += 1 + aop_map[op].op_size;
 443
 444       is_float = (op == aop_float);
 445     }
 446 }
 447
 448 /* Add register REG to the register mask for expression AX.  */
 449 void
 450 ax_reg_mask (struct agent_expr *ax, int reg)
 451 {
 452   if (reg >= gdbarch_num_regs (ax->gdbarch))
 453     {
 454       /* This is a pseudo-register.  */
 455       if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch))
 456         error (_("'%s' is a pseudo-register; "
 457                  "GDB cannot yet trace its contents."),
 458                user_reg_map_regnum_to_name (ax->gdbarch, reg));
 459       if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg))
 460         error (_("Trace '%s' failed."),
 461                user_reg_map_regnum_to_name (ax->gdbarch, reg));
 462     }
 463   else
 464     {
 465       int byte = reg / 8;
 466
 467       /* Grow the bit mask if necessary.  */
 468       if (byte >= ax->reg_mask_len)
 469         {
 470           /* It's not appropriate to double here.  This isn't a
 471              string buffer.  */
 472           int new_len = byte + 1;
 473           unsigned char *new_reg_mask = xrealloc (ax->reg_mask,
 474                                                   new_len
 475                                                   * sizeof (ax->reg_mask[0]));
 476           memset (new_reg_mask + ax->reg_mask_len, 0,
 477                   (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0]));
 478           ax->reg_mask_len = new_len;
 479           ax->reg_mask = new_reg_mask;
 480         }
 481
 482       ax->reg_mask[byte] |= 1 << (reg % 8);
 483     }
 484 }
 485
 486 /* Given an agent expression AX, fill in requirements and other descriptive
 487    bits.  */
 488 void
 489 ax_reqs (struct agent_expr *ax)
 490 {
 491   int i;
 492   int height;
 493
 494   /* Jump target table.  targets[i] is non-zero iff we have found a
 495      jump to offset i.  */
 496   char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
 497
 498   /* Instruction boundary table.  boundary[i] is non-zero iff our scan
 499      has reached an instruction starting at offset i.  */
 500   char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
 501
 502   /* Stack height record.  If either targets[i] or boundary[i] is
 503      non-zero, heights[i] is the height the stack should have before
 504      executing the bytecode at that point.  */
 505   int *heights = (int *) alloca (ax->len * sizeof (heights[0]));
 506
 507   /* Pointer to a description of the present op.  */
 508   struct aop_map *op;
 509
 510   memset (targets, 0, ax->len * sizeof (targets[0]));
 511   memset (boundary, 0, ax->len * sizeof (boundary[0]));
 512
 513   ax->max_height = ax->min_height = height = 0;
 514   ax->flaw = agent_flaw_none;
 515   ax->max_data_size = 0;
 516
 517   for (i = 0; i < ax->len; i += 1 + op->op_size)
 518     {
 519       if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
 520         {
 521           ax->flaw = agent_flaw_bad_instruction;
 522           return;
 523         }
 524
 525       op = &aop_map[ax->buf[i]];
 526
 527       if (!op->name)
 528         {
 529           ax->flaw = agent_flaw_bad_instruction;
 530           return;
 531         }
 532
 533       if (i + 1 + op->op_size > ax->len)
 534         {
 535           ax->flaw = agent_flaw_incomplete_instruction;
 536           return;
 537         }
 538
 539       /* If this instruction is a forward jump target, does the
 540          current stack height match the stack height at the jump
 541          source?  */
 542       if (targets[i] && (heights[i] != height))
 543         {
 544           ax->flaw = agent_flaw_height_mismatch;
 545           return;
 546         }
 547
 548       boundary[i] = 1;
 549       heights[i] = height;
 550
 551       height -= op->consumed;
 552       if (height < ax->min_height)
 553         ax->min_height = height;
 554       height += op->produced;
 555       if (height > ax->max_height)
 556         ax->max_height = height;
 557
 558       if (op->data_size > ax->max_data_size)
 559         ax->max_data_size = op->data_size;
 560
 561       /* For jump instructions, check that the target is a valid
 562          offset.  If it is, record the fact that that location is a
 563          jump target, and record the height we expect there.  */
 564       if (aop_goto == op - aop_map
 565           || aop_if_goto == op - aop_map)
 566         {
 567           int target = read_const (ax, i + 1, 2);
 568           if (target < 0 || target >= ax->len)
 569             {
 570               ax->flaw = agent_flaw_bad_jump;
 571               return;
 572             }
 573
 574           /* Do we have any information about what the stack height
 575              should be at the target?  */
 576           if (targets[target] || boundary[target])
 577             {
 578               if (heights[target] != height)
 579                 {
 580                   ax->flaw = agent_flaw_height_mismatch;
 581                   return;
 582                 }
 583             }
 584
 585           /* Record the target, along with the stack height we expect.  */
 586           targets[target] = 1;
 587           heights[target] = height;
 588         }
 589
 590       /* For unconditional jumps with a successor, check that the
 591          successor is a target, and pick up its stack height.  */
 592       if (aop_goto == op - aop_map
 593           && i + 3 < ax->len)
 594         {
 595           if (!targets[i + 3])
 596             {
 597               ax->flaw = agent_flaw_hole;
 598               return;
 599             }
 600
 601           height = heights[i + 3];
 602         }
 603
 604       /* For reg instructions, record the register in the bit mask.  */
 605       if (aop_reg == op - aop_map)
 606         {
 607           int reg = read_const (ax, i + 1, 2);
 608
 609           ax_reg_mask (ax, reg);
 610         }
 611     }
 612
 613   /* Check that all the targets are on boundaries.  */
 614   for (i = 0; i < ax->len; i++)
 615     if (targets[i] && !boundary[i])
 616       {
 617         ax->flaw = agent_flaw_bad_jump;
 618         return;
 619       }
 620
 621   ax->final_height = height;
 622 }