gdb/ax-general.c

   1 /* Functions for manipulating expressions designed to be executed on the agent
   2    Copyright (C) 1998, 1999, 2000 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 2 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, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19    Boston, MA 02110-1301, USA.  */
  20
  21 /* Despite what the above comment says about this file being part of
  22    GDB, we would like to keep these functions free of GDB
  23    dependencies, since we want to be able to use them in contexts
  24    outside of GDB (test suites, the stub, etc.)  */
  25
  26 #include "defs.h"
  27 #include "ax.h"
  28
  29 #include "value.h"
  30 #include "gdb_string.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 (CORE_ADDR scope)
  45 {
  46   struct agent_expr *x = xmalloc (sizeof (*x));
  47   x->len = 0;
  48   x->size = 1;                  /* Change this to a larger value once
  49                                    reallocation code is tested.  */
  50   x->buf = xmalloc (x->size);
  51   x->scope = scope;
  52
  53   return x;
  54 }
  55
  56 /* Free a agent expression.  */
  57 void
  58 free_agent_expr (struct agent_expr *x)
  59 {
  60   xfree (x->buf);
  61   xfree (x);
  62 }
  63
  64 static void
  65 do_free_agent_expr_cleanup (void *x)
  66 {
  67   free_agent_expr (x);
  68 }
  69
  70 struct cleanup *
  71 make_cleanup_free_agent_expr (struct agent_expr *x)
  72 {
  73   return make_cleanup (do_free_agent_expr_cleanup, x);
  74 }
  75
  76
  77 /* Make sure that X has room for at least N more bytes.  This doesn't
  78    affect the length, just the allocated size.  */
  79 static void
  80 grow_expr (struct agent_expr *x, int n)
  81 {
  82   if (x->len + n > x->size)
  83     {
  84       x->size *= 2;
  85       if (x->size < x->len + n)
  86         x->size = x->len + n + 10;
  87       x->buf = xrealloc (x->buf, x->size);
  88     }
  89 }
  90
  91
  92 /* Append the low N bytes of VAL as an N-byte integer to the
  93    expression X, in big-endian order.  */
  94 static void
  95 append_const (struct agent_expr *x, LONGEST val, int n)
  96 {
  97   int i;
  98
  99   grow_expr (x, n);
 100   for (i = n - 1; i >= 0; i--)
 101     {
 102       x->buf[x->len + i] = val & 0xff;
 103       val >>= 8;
 104     }
 105   x->len += n;
 106 }
 107
 108
 109 /* Extract an N-byte big-endian unsigned integer from expression X at
 110    offset O.  */
 111 static LONGEST
 112 read_const (struct agent_expr *x, int o, int n)
 113 {
 114   int i;
 115   LONGEST accum = 0;
 116
 117   /* Make sure we're not reading off the end of the expression.  */
 118   if (o + n > x->len)
 119     error (_("GDB bug: ax-general.c (read_const): incomplete constant"));
 120
 121   for (i = 0; i < n; i++)
 122     accum = (accum << 8) | x->buf[o + i];
 123
 124   return accum;
 125 }
 126
 127
 128 /* Append a simple operator OP to EXPR.  */
 129 void
 130 ax_simple (struct agent_expr *x, enum agent_op op)
 131 {
 132   grow_expr (x, 1);
 133   x->buf[x->len++] = op;
 134 }
 135
 136
 137 /* Append a sign-extension or zero-extension instruction to EXPR, to
 138    extend an N-bit value.  */
 139 static void
 140 generic_ext (struct agent_expr *x, enum agent_op op, int n)
 141 {
 142   /* N must fit in a byte.  */
 143   if (n < 0 || n > 255)
 144     error (_("GDB bug: ax-general.c (generic_ext): bit count out of range"));
 145   /* That had better be enough range.  */
 146   if (sizeof (LONGEST) * 8 > 255)
 147     error (_("GDB bug: ax-general.c (generic_ext): opcode has inadequate range"));
 148
 149   grow_expr (x, 2);
 150   x->buf[x->len++] = op;
 151   x->buf[x->len++] = n;
 152 }
 153
 154
 155 /* Append a sign-extension instruction to EXPR, to extend an N-bit value.  */
 156 void
 157 ax_ext (struct agent_expr *x, int n)
 158 {
 159   generic_ext (x, aop_ext, n);
 160 }
 161
 162
 163 /* Append a zero-extension instruction to EXPR, to extend an N-bit value.  */
 164 void
 165 ax_zero_ext (struct agent_expr *x, int n)
 166 {
 167   generic_ext (x, aop_zero_ext, n);
 168 }
 169
 170
 171 /* Append a trace_quick instruction to EXPR, to record N bytes.  */
 172 void
 173 ax_trace_quick (struct agent_expr *x, int n)
 174 {
 175   /* N must fit in a byte.  */
 176   if (n < 0 || n > 255)
 177     error (_("GDB bug: ax-general.c (ax_trace_quick): size out of range for trace_quick"));
 178
 179   grow_expr (x, 2);
 180   x->buf[x->len++] = aop_trace_quick;
 181   x->buf[x->len++] = n;
 182 }
 183
 184
 185 /* Append a goto op to EXPR.  OP is the actual op (must be aop_goto or
 186    aop_if_goto).  We assume we don't know the target offset yet,
 187    because it's probably a forward branch, so we leave space in EXPR
 188    for the target, and return the offset in EXPR of that space, so we
 189    can backpatch it once we do know the target offset.  Use ax_label
 190    to do the backpatching.  */
 191 int
 192 ax_goto (struct agent_expr *x, enum agent_op op)
 193 {
 194   grow_expr (x, 3);
 195   x->buf[x->len + 0] = op;
 196   x->buf[x->len + 1] = 0xff;
 197   x->buf[x->len + 2] = 0xff;
 198   x->len += 3;
 199   return x->len - 2;
 200 }
 201
 202 /* Suppose a given call to ax_goto returns some value PATCH.  When you
 203    know the offset TARGET that goto should jump to, call
 204    ax_label (EXPR, PATCH, TARGET)
 205    to patch TARGET into the ax_goto instruction.  */
 206 void
 207 ax_label (struct agent_expr *x, int patch, int target)
 208 {
 209   /* Make sure the value is in range.  Don't accept 0xffff as an
 210      offset; that's our magic sentinel value for unpatched branches.  */
 211   if (target < 0 || target >= 0xffff)
 212     error (_("GDB bug: ax-general.c (ax_label): label target out of range"));
 213
 214   x->buf[patch] = (target >> 8) & 0xff;
 215   x->buf[patch + 1] = target & 0xff;
 216 }
 217
 218
 219 /* Assemble code to push a constant on the stack.  */
 220 void
 221 ax_const_l (struct agent_expr *x, LONGEST l)
 222 {
 223   static enum agent_op ops[]
 224   =
 225   {aop_const8, aop_const16, aop_const32, aop_const64};
 226   int size;
 227   int op;
 228
 229   /* How big is the number?  'op' keeps track of which opcode to use.
 230      Notice that we don't really care whether the original number was
 231      signed or unsigned; we always reproduce the value exactly, and
 232      use the shortest representation.  */
 233   for (op = 0, size = 8; size < 64; size *= 2, op++)
 234     if (-((LONGEST) 1 << size) <= l && l < ((LONGEST) 1 << size))
 235       break;
 236
 237   /* Emit the right opcode... */
 238   ax_simple (x, ops[op]);
 239
 240   /* Emit the low SIZE bytes as an unsigned number.  We know that
 241      sign-extending this will yield l.  */
 242   append_const (x, l, size / 8);
 243
 244   /* Now, if it was negative, and not full-sized, sign-extend it.  */
 245   if (l < 0 && size < 64)
 246     ax_ext (x, size);
 247 }
 248
 249
 250 void
 251 ax_const_d (struct agent_expr *x, LONGEST d)
 252 {
 253   /* FIXME: floating-point support not present yet.  */
 254   error (_("GDB bug: ax-general.c (ax_const_d): floating point not supported yet"));
 255 }
 256
 257
 258 /* Assemble code to push the value of register number REG on the
 259    stack.  */
 260 void
 261 ax_reg (struct agent_expr *x, int reg)
 262 {
 263   /* Make sure the register number is in range.  */
 264   if (reg < 0 || reg > 0xffff)
 265     error (_("GDB bug: ax-general.c (ax_reg): register number out of range"));
 266   grow_expr (x, 3);
 267   x->buf[x->len] = aop_reg;
 268   x->buf[x->len + 1] = (reg >> 8) & 0xff;
 269   x->buf[x->len + 2] = (reg) & 0xff;
 270   x->len += 3;
 271 }
 272 \f
 273
 274
 275 /* Functions for disassembling agent expressions, and otherwise
 276    debugging the expression compiler.  */
 277
 278 struct aop_map aop_map[] =
 279 {
 280   {0, 0, 0, 0, 0},
 281   {"float", 0, 0, 0, 0},        /* 0x01 */
 282   {"add", 0, 0, 2, 1},          /* 0x02 */
 283   {"sub", 0, 0, 2, 1},          /* 0x03 */
 284   {"mul", 0, 0, 2, 1},          /* 0x04 */
 285   {"div_signed", 0, 0, 2, 1},   /* 0x05 */
 286   {"div_unsigned", 0, 0, 2, 1}, /* 0x06 */
 287   {"rem_signed", 0, 0, 2, 1},   /* 0x07 */
 288   {"rem_unsigned", 0, 0, 2, 1}, /* 0x08 */
 289   {"lsh", 0, 0, 2, 1},          /* 0x09 */
 290   {"rsh_signed", 0, 0, 2, 1},   /* 0x0a */
 291   {"rsh_unsigned", 0, 0, 2, 1}, /* 0x0b */
 292   {"trace", 0, 0, 2, 0},        /* 0x0c */
 293   {"trace_quick", 1, 0, 1, 1},  /* 0x0d */
 294   {"log_not", 0, 0, 1, 1},      /* 0x0e */
 295   {"bit_and", 0, 0, 2, 1},      /* 0x0f */
 296   {"bit_or", 0, 0, 2, 1},       /* 0x10 */
 297   {"bit_xor", 0, 0, 2, 1},      /* 0x11 */
 298   {"bit_not", 0, 0, 1, 1},      /* 0x12 */
 299   {"equal", 0, 0, 2, 1},        /* 0x13 */
 300   {"less_signed", 0, 0, 2, 1},  /* 0x14 */
 301   {"less_unsigned", 0, 0, 2, 1},        /* 0x15 */
 302   {"ext", 1, 0, 1, 1},          /* 0x16 */
 303   {"ref8", 0, 8, 1, 1},         /* 0x17 */
 304   {"ref16", 0, 16, 1, 1},       /* 0x18 */
 305   {"ref32", 0, 32, 1, 1},       /* 0x19 */
 306   {"ref64", 0, 64, 1, 1},       /* 0x1a */
 307   {"ref_float", 0, 0, 1, 1},    /* 0x1b */
 308   {"ref_double", 0, 0, 1, 1},   /* 0x1c */
 309   {"ref_long_double", 0, 0, 1, 1},      /* 0x1d */
 310   {"l_to_d", 0, 0, 1, 1},       /* 0x1e */
 311   {"d_to_l", 0, 0, 1, 1},       /* 0x1f */
 312   {"if_goto", 2, 0, 1, 0},      /* 0x20 */
 313   {"goto", 2, 0, 0, 0},         /* 0x21 */
 314   {"const8", 1, 8, 0, 1},       /* 0x22 */
 315   {"const16", 2, 16, 0, 1},     /* 0x23 */
 316   {"const32", 4, 32, 0, 1},     /* 0x24 */
 317   {"const64", 8, 64, 0, 1},     /* 0x25 */
 318   {"reg", 2, 0, 0, 1},          /* 0x26 */
 319   {"end", 0, 0, 0, 0},          /* 0x27 */
 320   {"dup", 0, 0, 1, 2},          /* 0x28 */
 321   {"pop", 0, 0, 1, 0},          /* 0x29 */
 322   {"zero_ext", 1, 0, 1, 1},     /* 0x2a */
 323   {"swap", 0, 0, 2, 2},         /* 0x2b */
 324   {0, 0, 0, 0, 0},              /* 0x2c */
 325   {0, 0, 0, 0, 0},              /* 0x2d */
 326   {0, 0, 0, 0, 0},              /* 0x2e */
 327   {0, 0, 0, 0, 0},              /* 0x2f */
 328   {"trace16", 2, 0, 1, 1},      /* 0x30 */
 329 };
 330
 331
 332 /* Disassemble the expression EXPR, writing to F.  */
 333 void
 334 ax_print (struct ui_file *f, struct agent_expr *x)
 335 {
 336   int i;
 337   int is_float = 0;
 338
 339   /* Check the size of the name array against the number of entries in
 340      the enum, to catch additions that people didn't sync.  */
 341   if ((sizeof (aop_map) / sizeof (aop_map[0]))
 342       != aop_last)
 343     error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
 344
 345   for (i = 0; i < x->len;)
 346     {
 347       enum agent_op op = x->buf[i];
 348
 349       if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
 350           || !aop_map[op].name)
 351         {
 352           fprintf_filtered (f, _("%3d  <bad opcode %02x>\n"), i, op);
 353           i++;
 354           continue;
 355         }
 356       if (i + 1 + aop_map[op].op_size > x->len)
 357         {
 358           fprintf_filtered (f, _("%3d  <incomplete opcode %s>\n"),
 359                             i, aop_map[op].name);
 360           break;
 361         }
 362
 363       fprintf_filtered (f, "%3d  %s", i, aop_map[op].name);
 364       if (aop_map[op].op_size > 0)
 365         {
 366           fputs_filtered (" ", f);
 367
 368           print_longest (f, 'd', 0,
 369                          read_const (x, i + 1, aop_map[op].op_size));
 370         }
 371       fprintf_filtered (f, "\n");
 372       i += 1 + aop_map[op].op_size;
 373
 374       is_float = (op == aop_float);
 375     }
 376 }
 377
 378
 379 /* Given an agent expression AX, fill in an agent_reqs structure REQS
 380    describing it.  */
 381 void
 382 ax_reqs (struct agent_expr *ax, struct agent_reqs *reqs)
 383 {
 384   int i;
 385   int height;
 386
 387   /* Bit vector for registers used.  */
 388   int reg_mask_len = 1;
 389   unsigned char *reg_mask = xmalloc (reg_mask_len * sizeof (reg_mask[0]));
 390
 391   /* Jump target table.  targets[i] is non-zero iff we have found a
 392      jump to offset i.  */
 393   char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
 394
 395   /* Instruction boundary table.  boundary[i] is non-zero iff our scan
 396      has reached an instruction starting at offset i.  */
 397   char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
 398
 399   /* Stack height record.  If either targets[i] or boundary[i] is
 400      non-zero, heights[i] is the height the stack should have before
 401      executing the bytecode at that point.  */
 402   int *heights = (int *) alloca (ax->len * sizeof (heights[0]));
 403
 404   /* Pointer to a description of the present op.  */
 405   struct aop_map *op;
 406
 407   memset (reg_mask, 0, reg_mask_len * sizeof (reg_mask[0]));
 408   memset (targets, 0, ax->len * sizeof (targets[0]));
 409   memset (boundary, 0, ax->len * sizeof (boundary[0]));
 410
 411   reqs->max_height = reqs->min_height = height = 0;
 412   reqs->flaw = agent_flaw_none;
 413   reqs->max_data_size = 0;
 414
 415   for (i = 0; i < ax->len; i += 1 + op->op_size)
 416     {
 417       if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
 418         {
 419           reqs->flaw = agent_flaw_bad_instruction;
 420           xfree (reg_mask);
 421           return;
 422         }
 423
 424       op = &aop_map[ax->buf[i]];
 425
 426       if (!op->name)
 427         {
 428           reqs->flaw = agent_flaw_bad_instruction;
 429           xfree (reg_mask);
 430           return;
 431         }
 432
 433       if (i + 1 + op->op_size > ax->len)
 434         {
 435           reqs->flaw = agent_flaw_incomplete_instruction;
 436           xfree (reg_mask);
 437           return;
 438         }
 439
 440       /* If this instruction is a forward jump target, does the
 441          current stack height match the stack height at the jump
 442          source?  */
 443       if (targets[i] && (heights[i] != height))
 444         {
 445           reqs->flaw = agent_flaw_height_mismatch;
 446           xfree (reg_mask);
 447           return;
 448         }
 449
 450       boundary[i] = 1;
 451       heights[i] = height;
 452
 453       height -= op->consumed;
 454       if (height < reqs->min_height)
 455         reqs->min_height = height;
 456       height += op->produced;
 457       if (height > reqs->max_height)
 458         reqs->max_height = height;
 459
 460       if (op->data_size > reqs->max_data_size)
 461         reqs->max_data_size = op->data_size;
 462
 463       /* For jump instructions, check that the target is a valid
 464          offset.  If it is, record the fact that that location is a
 465          jump target, and record the height we expect there.  */
 466       if (aop_goto == op - aop_map
 467           || aop_if_goto == op - aop_map)
 468         {
 469           int target = read_const (ax, i + 1, 2);
 470           if (target < 0 || target >= ax->len)
 471             {
 472               reqs->flaw = agent_flaw_bad_jump;
 473               xfree (reg_mask);
 474               return;
 475             }
 476
 477           /* Do we have any information about what the stack height
 478              should be at the target?  */
 479           if (targets[target] || boundary[target])
 480             {
 481               if (heights[target] != height)
 482                 {
 483                   reqs->flaw = agent_flaw_height_mismatch;
 484                   xfree (reg_mask);
 485                   return;
 486                 }
 487             }
 488
 489           /* Record the target, along with the stack height we expect.  */
 490           targets[target] = 1;
 491           heights[target] = height;
 492         }
 493
 494       /* For unconditional jumps with a successor, check that the
 495          successor is a target, and pick up its stack height.  */
 496       if (aop_goto == op - aop_map
 497           && i + 3 < ax->len)
 498         {
 499           if (!targets[i + 3])
 500             {
 501               reqs->flaw = agent_flaw_hole;
 502               xfree (reg_mask);
 503               return;
 504             }
 505
 506           height = heights[i + 3];
 507         }
 508
 509       /* For reg instructions, record the register in the bit mask.  */
 510       if (aop_reg == op - aop_map)
 511         {
 512           int reg = read_const (ax, i + 1, 2);
 513           int byte = reg / 8;
 514
 515           /* Grow the bit mask if necessary.  */
 516           if (byte >= reg_mask_len)
 517             {
 518               /* It's not appropriate to double here.  This isn't a
 519                  string buffer.  */
 520               int new_len = byte + 1;
 521               reg_mask = xrealloc (reg_mask,
 522                                    new_len * sizeof (reg_mask[0]));
 523               memset (reg_mask + reg_mask_len, 0,
 524                       (new_len - reg_mask_len) * sizeof (reg_mask[0]));
 525               reg_mask_len = new_len;
 526             }
 527
 528           reg_mask[byte] |= 1 << (reg % 8);
 529         }
 530     }
 531
 532   /* Check that all the targets are on boundaries.  */
 533   for (i = 0; i < ax->len; i++)
 534     if (targets[i] && !boundary[i])
 535       {
 536         reqs->flaw = agent_flaw_bad_jump;
 537         xfree (reg_mask);
 538         return;
 539       }
 540
 541   reqs->final_height = height;
 542   reqs->reg_mask_len = reg_mask_len;
 543   reqs->reg_mask = reg_mask;
 544 }