gdb/ax-general.c

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