gdb/ax-general.c

   1 /* Functions for manipulating expressions designed to be executed on the agent
   2    Copyright (C) 1998-2000, 2007-2012 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, 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   int is_float = 0;
 379
 380   fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
 381   fprintf_filtered (f, _("Reg mask:"));
 382   for (i = 0; i < x->reg_mask_len; ++i)
 383     fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
 384   fprintf_filtered (f, _("\n"));
 385
 386   /* Check the size of the name array against the number of entries in
 387      the enum, to catch additions that people didn't sync.  */
 388   if ((sizeof (aop_map) / sizeof (aop_map[0]))
 389       != aop_last)
 390     error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
 391
 392   for (i = 0; i < x->len;)
 393     {
 394       enum agent_op op = x->buf[i];
 395
 396       if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
 397           || !aop_map[op].name)
 398         {
 399           fprintf_filtered (f, _("%3d  <bad opcode %02x>\n"), i, op);
 400           i++;
 401           continue;
 402         }
 403       if (i + 1 + aop_map[op].op_size > x->len)
 404         {
 405           fprintf_filtered (f, _("%3d  <incomplete opcode %s>\n"),
 406                             i, aop_map[op].name);
 407           break;
 408         }
 409
 410       fprintf_filtered (f, "%3d  %s", i, aop_map[op].name);
 411       if (aop_map[op].op_size > 0)
 412         {
 413           fputs_filtered (" ", f);
 414
 415           print_longest (f, 'd', 0,
 416                          read_const (x, i + 1, aop_map[op].op_size));
 417         }
 418       /* Handle the complicated printf arguments specially.  */
 419       else if (op == aop_printf)
 420         {
 421           int slen, nargs;
 422
 423           i++;
 424           nargs = x->buf[i++];
 425           slen = x->buf[i++];
 426           slen = slen * 256 + x->buf[i++];
 427           fprintf_filtered (f, _(" \"%s\", %d args"),
 428                             &(x->buf[i]), nargs);
 429           i += slen - 1;
 430         }
 431       fprintf_filtered (f, "\n");
 432       i += 1 + aop_map[op].op_size;
 433
 434       is_float = (op == aop_float);
 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 }