1 /* Functions for manipulating expressions designed to be executed on the agent
2 Copyright 1998 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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. */
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.) */
30 static void grow_expr
PARAMS ((struct agent_expr
*x
, int n
));
32 static void append_const
PARAMS ((struct agent_expr
*x
, LONGEST val
, int n
));
34 static LONGEST read_const
PARAMS ((struct agent_expr
*x
, int o
, int n
));
36 static void generic_ext
PARAMS ((struct agent_expr
*x
, enum agent_op op
, int n
));
38 /* Functions for building expressions. */
40 /* Allocate a new, empty agent expression. */
42 new_agent_expr (scope
)
45 struct agent_expr
*x
= xmalloc (sizeof (*x
));
47 x
->size
= 1; /* Change this to a larger value once
48 reallocation code is tested. */
49 x
->buf
= xmalloc (x
->size
);
55 /* Free a agent expression. */
65 /* Make sure that X has room for at least N more bytes. This doesn't
66 affect the length, just the allocated size. */
72 if (x
->len
+ n
> x
->size
)
75 if (x
->size
< x
->len
+ n
)
76 x
->size
= x
->len
+ n
+ 10;
77 x
->buf
= xrealloc (x
->buf
, x
->size
);
82 /* Append the low N bytes of VAL as an N-byte integer to the
83 expression X, in big-endian order. */
85 append_const (x
, val
, n
)
93 for (i
= n
- 1; i
>= 0; i
--)
95 x
->buf
[x
->len
+ i
] = val
& 0xff;
102 /* Extract an N-byte big-endian unsigned integer from expression X at
106 struct agent_expr
*x
;
112 /* Make sure we're not reading off the end of the expression. */
114 error ("GDB bug: ax-general.c (read_const): incomplete constant");
116 for (i
= 0; i
< n
; i
++)
117 accum
= (accum
<< 8) | x
->buf
[o
+ i
];
123 /* Append a simple operator OP to EXPR. */
126 struct agent_expr
*x
;
130 x
->buf
[x
->len
++] = op
;
134 /* Append a sign-extension or zero-extension instruction to EXPR, to
135 extend an N-bit value. */
137 generic_ext (x
, op
, n
)
138 struct agent_expr
*x
;
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");
150 x
->buf
[x
->len
++] = op
;
151 x
->buf
[x
->len
++] = n
;
155 /* Append a sign-extension instruction to EXPR, to extend an N-bit value. */
158 struct agent_expr
*x
;
161 generic_ext (x
, aop_ext
, n
);
165 /* Append a zero-extension instruction to EXPR, to extend an N-bit value. */
168 struct agent_expr
*x
;
171 generic_ext (x
, aop_zero_ext
, n
);
175 /* Append a trace_quick instruction to EXPR, to record N bytes. */
177 ax_trace_quick (x
, n
)
178 struct agent_expr
*x
;
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");
186 x
->buf
[x
->len
++] = aop_trace_quick
;
187 x
->buf
[x
->len
++] = n
;
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. */
198 struct agent_expr
*x
;
202 x
->buf
[x
->len
+ 0] = op
;
203 x
->buf
[x
->len
+ 1] = 0xff;
204 x
->buf
[x
->len
+ 2] = 0xff;
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. */
214 ax_label (x
, patch
, target
)
215 struct agent_expr
*x
;
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");
224 x
->buf
[patch
] = (target
>> 8) & 0xff;
225 x
->buf
[patch
+ 1] = target
& 0xff;
229 /* Assemble code to push a constant on the stack. */
232 struct agent_expr
*x
;
235 static enum agent_op ops
[]
236 = { aop_const8
, aop_const16
, aop_const32
, aop_const64
};
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
))
248 /* Emit the right opcode... */
249 ax_simple (x
, ops
[op
]);
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);
255 /* Now, if it was negative, and not full-sized, sign-extend it. */
256 if (l
< 0 && size
< 64)
263 struct agent_expr
*x
;
266 /* FIXME: floating-point support not present yet. */
267 error ("GDB bug: ax-general.c (ax_const_d): floating point not supported yet");
271 /* Assemble code to push the value of register number REG on the
274 struct agent_expr
*x
;
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");
281 x
->buf
[x
->len
] = aop_reg
;
282 x
->buf
[x
->len
+ 1] = (reg
>> 8) & 0xff;
283 x
->buf
[x
->len
+ 2] = (reg
) & 0xff;
289 /* Functions for disassembling agent expressions, and otherwise
290 debugging the expression compiler. */
292 struct aop_map aop_map
[] = {
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 */
345 /* Disassemble the expression EXPR, writing to F. */
349 struct agent_expr
*x
;
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]))
358 error ("GDB bug: ax-general.c (ax_print): opcode map out of sync");
360 for (i
= 0; i
< x
->len
; )
362 enum agent_op op
= x
->buf
[i
];
364 if (op
>= (sizeof (aop_map
) / sizeof (aop_map
[0]))
365 || ! aop_map
[op
].name
)
367 fprintf_filtered (f
, "%3d <bad opcode %02x>\n", i
, op
);
371 if (i
+ 1 + aop_map
[op
].op_size
> x
->len
)
373 fprintf_filtered (f
, "%3d <incomplete opcode %s>\n",
374 i
, aop_map
[op
].name
);
378 fprintf_filtered (f
, "%3d %s", i
, aop_map
[op
].name
);
379 if (aop_map
[op
].op_size
> 0)
381 fputs_filtered (" ", f
);
383 print_longest (f
, 'd', 0,
384 read_const (x
, i
+ 1, aop_map
[op
].op_size
));
386 fprintf_filtered (f
, "\n");
387 i
+= 1 + aop_map
[op
].op_size
;
389 is_float
= (op
== aop_float
);
394 /* Given an agent expression AX, fill in an agent_reqs structure REQS
398 struct agent_expr
*ax
;
399 struct agent_reqs
*reqs
;
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]));
408 /* Jump target table. targets[i] is non-zero iff there is a jump to
410 char *targets
= (char *) alloca (ax
->len
* sizeof (targets
[0]));
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]));
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]));
421 /* Pointer to a description of the present op. */
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]));
428 reqs
->max_height
= reqs
->min_height
= height
= 0;
429 reqs
->flaw
= agent_flaw_none
;
430 reqs
->max_data_size
= 0;
432 for (i
= 0; i
< ax
->len
; i
+= 1 + op
->op_size
)
434 if (ax
->buf
[i
] > (sizeof (aop_map
) / sizeof (aop_map
[0])))
436 reqs
->flaw
= agent_flaw_bad_instruction
;
441 op
= &aop_map
[ax
->buf
[i
]];
445 reqs
->flaw
= agent_flaw_bad_instruction
;
450 if (i
+ 1 + op
->op_size
> ax
->len
)
452 reqs
->flaw
= agent_flaw_incomplete_instruction
;
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
))
461 reqs
->flaw
= agent_flaw_height_mismatch
;
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
;
476 if (op
->data_size
> reqs
->max_data_size
)
477 reqs
->max_data_size
= op
->data_size
;
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
)
485 int target
= read_const (ax
, i
+ 1, 2);
486 if (target
< 0 || target
>= ax
->len
)
488 reqs
->flaw
= agent_flaw_bad_jump
;
492 /* Have we already found other jumps to the same location? */
493 else if (targets
[target
])
495 if (heights
[i
] != height
)
497 reqs
->flaw
= agent_flaw_height_mismatch
;
505 heights
[target
] = height
;
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
514 if (! targets
[i
+ 3])
516 reqs
->flaw
= agent_flaw_hole
;
521 height
= heights
[i
+ 3];
524 /* For reg instructions, record the register in the bit mask. */
525 if (aop_reg
== op
- aop_map
)
527 int reg
= read_const (ax
, i
+ 1, 2);
530 /* Grow the bit mask if necessary. */
531 if (byte
>= reg_mask_len
)
533 /* It's not appropriate to double here. This isn't a
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
;
543 reg_mask
[byte
] |= 1 << (reg
% 8);
547 /* Check that all the targets are on boundaries. */
548 for (i
= 0; i
< ax
->len
; i
++)
549 if (targets
[i
] && !boundary
[i
])
551 reqs
->flaw
= agent_flaw_bad_jump
;
556 reqs
->final_height
= height
;
557 reqs
->reg_mask_len
= reg_mask_len
;
558 reqs
->reg_mask
= reg_mask
;