gdb/ax-general.c

   1 /* Functions for manipulating expressions designed to be executed on the agent
   2    Copyright 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., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, 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 there is a jump to
 392      offset i.  */
 393   char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
 394
 395   /* Instruction boundary table.  boundary[i] is non-zero iff an
 396      instruction starts at offset i.  */
 397   char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
 398
 399   /* Stack height record.  iff 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 jump target, does the current stack
 441          height match the stack height at the jump source?  */
 442       if (targets[i] && (heights[i] != height))
 443         {
 444           reqs->flaw = agent_flaw_height_mismatch;
 445           xfree (reg_mask);
 446           return;
 447         }
 448
 449       boundary[i] = 1;
 450       heights[i] = height;
 451
 452       height -= op->consumed;
 453       if (height < reqs->min_height)
 454         reqs->min_height = height;
 455       height += op->produced;
 456       if (height > reqs->max_height)
 457         reqs->max_height = height;
 458
 459       if (op->data_size > reqs->max_data_size)
 460         reqs->max_data_size = op->data_size;
 461
 462       /* For jump instructions, check that the target is a valid
 463          offset.  If it is, record the fact that that location is a
 464          jump target, and record the height we expect there.  */
 465       if (aop_goto == op - aop_map
 466           || aop_if_goto == op - aop_map)
 467         {
 468           int target = read_const (ax, i + 1, 2);
 469           if (target < 0 || target >= ax->len)
 470             {
 471               reqs->flaw = agent_flaw_bad_jump;
 472               xfree (reg_mask);
 473               return;
 474             }
 475           /* Have we already found other jumps to the same location?  */
 476           else if (targets[target])
 477             {
 478               if (heights[i] != height)
 479                 {
 480                   reqs->flaw = agent_flaw_height_mismatch;
 481                   xfree (reg_mask);
 482                   return;
 483                 }
 484             }
 485           else
 486             {
 487               targets[target] = 1;
 488               heights[target] = height;
 489             }
 490         }
 491
 492       /* For unconditional jumps with a successor, check that the
 493          successor is a target, and pick up its stack height.  */
 494       if (aop_goto == op - aop_map
 495           && i + 3 < ax->len)
 496         {
 497           if (!targets[i + 3])
 498             {
 499               reqs->flaw = agent_flaw_hole;
 500               xfree (reg_mask);
 501               return;
 502             }
 503
 504           height = heights[i + 3];
 505         }
 506
 507       /* For reg instructions, record the register in the bit mask.  */
 508       if (aop_reg == op - aop_map)
 509         {
 510           int reg = read_const (ax, i + 1, 2);
 511           int byte = reg / 8;
 512
 513           /* Grow the bit mask if necessary.  */
 514           if (byte >= reg_mask_len)
 515             {
 516               /* It's not appropriate to double here.  This isn't a
 517                  string buffer.  */
 518               int new_len = byte + 1;
 519               reg_mask = xrealloc (reg_mask,
 520                                    new_len * sizeof (reg_mask[0]));
 521               memset (reg_mask + reg_mask_len, 0,
 522                       (new_len - reg_mask_len) * sizeof (reg_mask[0]));
 523               reg_mask_len = new_len;
 524             }
 525
 526           reg_mask[byte] |= 1 << (reg % 8);
 527         }
 528     }
 529
 530   /* Check that all the targets are on boundaries.  */
 531   for (i = 0; i < ax->len; i++)
 532     if (targets[i] && !boundary[i])
 533       {
 534         reqs->flaw = agent_flaw_bad_jump;
 535         xfree (reg_mask);
 536         return;
 537       }
 538
 539   reqs->final_height = height;
 540   reqs->reg_mask_len = reg_mask_len;
 541   reqs->reg_mask = reg_mask;
 542 }