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