1 /* wrstabs.c -- Output stabs debugging information
2 Copyright 1996, 1997, 1998, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>.
5
6 This file is part of GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
22
23 /* This file contains code which writes out stabs debugging
24 information. */
25
26 #include <stdio.h>
27 #include <assert.h>
28
29 #include "bfd.h"
30 #include "bucomm.h"
31 #include "libiberty.h"
32 #include "safe-ctype.h"
33 #include "debug.h"
34 #include "budbg.h"
35 #include "aout/aout64.h"
36 #include "aout/stab_gnu.h"
37
38 /* The size of a stabs symbol. This presumes 32 bit values. */
39
40 #define STAB_SYMBOL_SIZE (12)
41
42 /* An entry in a string hash table. */
43
44 struct string_hash_entry
45 {
46 struct bfd_hash_entry root;
47 /* Next string in this table. */
48 struct string_hash_entry *next;
49 /* Index in string table. */
50 long index;
51 /* Size of type if this is a typedef. */
52 unsigned int size;
53 };
54
55 /* A string hash table. */
56
57 struct string_hash_table
58 {
59 struct bfd_hash_table table;
60 };
61
62 /* The type stack. Each element on the stack is a string. */
63
64 struct stab_type_stack
65 {
66 /* The next element on the stack. */
67 struct stab_type_stack *next;
68 /* This element as a string. */
69 char *string;
70 /* The type index of this element. */
71 long index;
72 /* The size of the type. */
73 unsigned int size;
74 /* Whether type string defines a new type. */
75 bfd_boolean definition;
76 /* String defining struct fields. */
77 char *fields;
78 /* NULL terminated array of strings defining base classes for a
79 class. */
80 char **baseclasses;
81 /* String defining class methods. */
82 char *methods;
83 /* String defining vtable pointer for a class. */
84 char *vtable;
85 };
86
87 /* This structure is used to keep track of type indices for tagged
88 types. */
89
90 struct stab_tag
91 {
92 /* The type index. */
93 long index;
94 /* The tag name. */
95 const char *tag;
96 /* The kind of type. This is set to DEBUG_KIND_ILLEGAL when the
97 type is defined. */
98 enum debug_type_kind kind;
99 /* The size of the struct. */
100 unsigned int size;
101 };
102
103 /* We remember various sorts of type indices. They are not related,
104 but, for convenience, we keep all the information in this
105 structure. */
106
107 struct stab_type_cache
108 {
109 /* The void type index. */
110 long void_type;
111 /* Signed integer type indices, indexed by size - 1. */
112 long signed_integer_types[8];
113 /* Unsigned integer type indices, indexed by size - 1. */
114 long unsigned_integer_types[8];
115 /* Floating point types, indexed by size - 1. */
116 long float_types[16];
117 /* Pointers to types, indexed by the type index. */
118 long *pointer_types;
119 size_t pointer_types_alloc;
120 /* Functions returning types, indexed by the type index. */
121 long *function_types;
122 size_t function_types_alloc;
123 /* References to types, indexed by the type index. */
124 long *reference_types;
125 size_t reference_types_alloc;
126 /* Struct/union/class type indices, indexed by the struct id. */
127 struct stab_tag *struct_types;
128 size_t struct_types_alloc;
129 };
130
131 /* This is the handle passed through debug_write. */
132
133 struct stab_write_handle
134 {
135 /* The BFD. */
136 bfd *abfd;
137 /* This buffer holds the symbols. */
138 bfd_byte *symbols;
139 size_t symbols_size;
140 size_t symbols_alloc;
141 /* This is a list of hash table entries for the strings. */
142 struct string_hash_entry *strings;
143 /* The last string hash table entry. */
144 struct string_hash_entry *last_string;
145 /* The size of the strings. */
146 size_t strings_size;
147 /* This hash table eliminates duplicate strings. */
148 struct string_hash_table strhash;
149 /* The type stack. */
150 struct stab_type_stack *type_stack;
151 /* The next type index. */
152 long type_index;
153 /* The type cache. */
154 struct stab_type_cache type_cache;
155 /* A mapping from typedef names to type indices. */
156 struct string_hash_table typedef_hash;
157 /* If this is not -1, it is the offset to the most recent N_SO
158 symbol, and the value of that symbol needs to be set. */
159 long so_offset;
160 /* If this is not -1, it is the offset to the most recent N_FUN
161 symbol, and the value of that symbol needs to be set. */
162 long fun_offset;
163 /* The last text section address seen. */
164 bfd_vma last_text_address;
165 /* The block nesting depth. */
166 unsigned int nesting;
167 /* The function address. */
168 bfd_vma fnaddr;
169 /* A pending LBRAC symbol. */
170 bfd_vma pending_lbrac;
171 /* The current line number file name. */
172 const char *lineno_filename;
173 };
174
175 static struct bfd_hash_entry *string_hash_newfunc
176 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
177 static bfd_boolean stab_write_symbol
178 (struct stab_write_handle *, int, int, bfd_vma, const char *);
179 static bfd_boolean stab_push_string
180 (struct stab_write_handle *, const char *, long, bfd_boolean, unsigned int);
181 static bfd_boolean stab_push_defined_type
182 (struct stab_write_handle *, long, unsigned int);
183 static char *stab_pop_type (struct stab_write_handle *);
184 static bfd_boolean stab_modify_type
185 (struct stab_write_handle *, int, unsigned int, long **, size_t *);
186 static long stab_get_struct_index
187 (struct stab_write_handle *, const char *, unsigned int,
188 enum debug_type_kind, unsigned int *);
189 static bfd_boolean stab_class_method_var
190 (struct stab_write_handle *, const char *, enum debug_visibility,
191 bfd_boolean, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
192 static bfd_boolean stab_start_compilation_unit (void *, const char *);
193 static bfd_boolean stab_start_source (void *, const char *);
194 static bfd_boolean stab_empty_type (void *);
195 static bfd_boolean stab_void_type (void *);
196 static bfd_boolean stab_int_type (void *, unsigned int, bfd_boolean);
197 static bfd_boolean stab_float_type (void *, unsigned int);
198 static bfd_boolean stab_complex_type (void *, unsigned int);
199 static bfd_boolean stab_bool_type (void *, unsigned int);
200 static bfd_boolean stab_enum_type
201 (void *, const char *, const char **, bfd_signed_vma *);
202 static bfd_boolean stab_pointer_type (void *);
203 static bfd_boolean stab_function_type (void *, int, bfd_boolean);
204 static bfd_boolean stab_reference_type (void *);
205 static bfd_boolean stab_range_type (void *, bfd_signed_vma, bfd_signed_vma);
206 static bfd_boolean stab_array_type
207 (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
208 static bfd_boolean stab_set_type (void *, bfd_boolean);
209 static bfd_boolean stab_offset_type (void *);
210 static bfd_boolean stab_method_type (void *, bfd_boolean, int, bfd_boolean);
211 static bfd_boolean stab_const_type (void *);
212 static bfd_boolean stab_volatile_type (void *);
213 static bfd_boolean stab_start_struct_type
214 (void *, const char *, unsigned int, bfd_boolean, unsigned int);
215 static bfd_boolean stab_struct_field
216 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
217 static bfd_boolean stab_end_struct_type (void *);
218 static bfd_boolean stab_start_class_type
219 (void *, const char *, unsigned int, bfd_boolean, unsigned int,
220 bfd_boolean, bfd_boolean);
221 static bfd_boolean stab_class_static_member
222 (void *, const char *, const char *, enum debug_visibility);
223 static bfd_boolean stab_class_baseclass
224 (void *, bfd_vma, bfd_boolean, enum debug_visibility);
225 static bfd_boolean stab_class_start_method (void *, const char *);
226 static bfd_boolean stab_class_method_variant
227 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
228 bfd_vma, bfd_boolean);
229 static bfd_boolean stab_class_static_method_variant
230 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
231 static bfd_boolean stab_class_end_method (void *);
232 static bfd_boolean stab_end_class_type (void *);
233 static bfd_boolean stab_typedef_type (void *, const char *);
234 static bfd_boolean stab_tag_type
235 (void *, const char *, unsigned int, enum debug_type_kind);
236 static bfd_boolean stab_typdef (void *, const char *);
237 static bfd_boolean stab_tag (void *, const char *);
238 static bfd_boolean stab_int_constant (void *, const char *, bfd_vma);
239 static bfd_boolean stab_float_constant (void *, const char *, double);
240 static bfd_boolean stab_typed_constant (void *, const char *, bfd_vma);
241 static bfd_boolean stab_variable
242 (void *, const char *, enum debug_var_kind, bfd_vma);
243 static bfd_boolean stab_start_function (void *, const char *, bfd_boolean);
244 static bfd_boolean stab_function_parameter
245 (void *, const char *, enum debug_parm_kind, bfd_vma);
246 static bfd_boolean stab_start_block (void *, bfd_vma);
247 static bfd_boolean stab_end_block (void *, bfd_vma);
248 static bfd_boolean stab_end_function (void *);
249 static bfd_boolean stab_lineno (void *, const char *, unsigned long, bfd_vma);
250
251 static const struct debug_write_fns stab_fns =
252 {
253 stab_start_compilation_unit,
254 stab_start_source,
255 stab_empty_type,
256 stab_void_type,
257 stab_int_type,
258 stab_float_type,
259 stab_complex_type,
260 stab_bool_type,
261 stab_enum_type,
262 stab_pointer_type,
263 stab_function_type,
264 stab_reference_type,
265 stab_range_type,
266 stab_array_type,
267 stab_set_type,
268 stab_offset_type,
269 stab_method_type,
270 stab_const_type,
271 stab_volatile_type,
272 stab_start_struct_type,
273 stab_struct_field,
274 stab_end_struct_type,
275 stab_start_class_type,
276 stab_class_static_member,
277 stab_class_baseclass,
278 stab_class_start_method,
279 stab_class_method_variant,
280 stab_class_static_method_variant,
281 stab_class_end_method,
282 stab_end_class_type,
283 stab_typedef_type,
284 stab_tag_type,
285 stab_typdef,
286 stab_tag,
287 stab_int_constant,
288 stab_float_constant,
289 stab_typed_constant,
290 stab_variable,
291 stab_start_function,
292 stab_function_parameter,
293 stab_start_block,
294 stab_end_block,
295 stab_end_function,
296 stab_lineno
297 };
298
299 /* Routine to create an entry in a string hash table. */
300
301 static struct bfd_hash_entry *
string_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)302 string_hash_newfunc (struct bfd_hash_entry *entry,
303 struct bfd_hash_table *table, const char *string)
304 {
305 struct string_hash_entry *ret = (struct string_hash_entry *) entry;
306
307 /* Allocate the structure if it has not already been allocated by a
308 subclass. */
309 if (ret == (struct string_hash_entry *) NULL)
310 ret = ((struct string_hash_entry *)
311 bfd_hash_allocate (table, sizeof (struct string_hash_entry)));
312 if (ret == (struct string_hash_entry *) NULL)
313 return NULL;
314
315 /* Call the allocation method of the superclass. */
316 ret = ((struct string_hash_entry *)
317 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
318
319 if (ret)
320 {
321 /* Initialize the local fields. */
322 ret->next = NULL;
323 ret->index = -1;
324 ret->size = 0;
325 }
326
327 return (struct bfd_hash_entry *) ret;
328 }
329
330 /* Look up an entry in a string hash table. */
331
332 #define string_hash_lookup(t, string, create, copy) \
333 ((struct string_hash_entry *) \
334 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
335
336 /* Add a symbol to the stabs debugging information we are building. */
337
338 static bfd_boolean
stab_write_symbol(struct stab_write_handle * info,int type,int desc,bfd_vma value,const char * string)339 stab_write_symbol (struct stab_write_handle *info, int type, int desc,
340 bfd_vma value, const char *string)
341 {
342 bfd_size_type strx;
343 bfd_byte sym[STAB_SYMBOL_SIZE];
344
345 if (string == NULL)
346 strx = 0;
347 else
348 {
349 struct string_hash_entry *h;
350
351 h = string_hash_lookup (&info->strhash, string, TRUE, TRUE);
352 if (h == NULL)
353 {
354 non_fatal (_("string_hash_lookup failed: %s"),
355 bfd_errmsg (bfd_get_error ()));
356 return FALSE;
357 }
358 if (h->index != -1)
359 strx = h->index;
360 else
361 {
362 strx = info->strings_size;
363 h->index = strx;
364 if (info->last_string == NULL)
365 info->strings = h;
366 else
367 info->last_string->next = h;
368 info->last_string = h;
369 info->strings_size += strlen (string) + 1;
370 }
371 }
372
373 /* This presumes 32 bit values. */
374 bfd_put_32 (info->abfd, strx, sym);
375 bfd_put_8 (info->abfd, type, sym + 4);
376 bfd_put_8 (info->abfd, 0, sym + 5);
377 bfd_put_16 (info->abfd, desc, sym + 6);
378 bfd_put_32 (info->abfd, value, sym + 8);
379
380 if (info->symbols_size + STAB_SYMBOL_SIZE > info->symbols_alloc)
381 {
382 info->symbols_alloc *= 2;
383 info->symbols = (bfd_byte *) xrealloc (info->symbols,
384 info->symbols_alloc);
385 }
386
387 memcpy (info->symbols + info->symbols_size, sym, STAB_SYMBOL_SIZE);
388
389 info->symbols_size += STAB_SYMBOL_SIZE;
390
391 return TRUE;
392 }
393
394 /* Push a string on to the type stack. */
395
396 static bfd_boolean
stab_push_string(struct stab_write_handle * info,const char * string,long index,bfd_boolean definition,unsigned int size)397 stab_push_string (struct stab_write_handle *info, const char *string,
398 long index, bfd_boolean definition, unsigned int size)
399 {
400 struct stab_type_stack *s;
401
402 s = (struct stab_type_stack *) xmalloc (sizeof *s);
403 s->string = xstrdup (string);
404 s->index = index;
405 s->definition = definition;
406 s->size = size;
407
408 s->fields = NULL;
409 s->baseclasses = NULL;
410 s->methods = NULL;
411 s->vtable = NULL;
412
413 s->next = info->type_stack;
414 info->type_stack = s;
415
416 return TRUE;
417 }
418
419 /* Push a type index which has already been defined. */
420
421 static bfd_boolean
stab_push_defined_type(struct stab_write_handle * info,long index,unsigned int size)422 stab_push_defined_type (struct stab_write_handle *info, long index,
423 unsigned int size)
424 {
425 char buf[20];
426
427 sprintf (buf, "%ld", index);
428 return stab_push_string (info, buf, index, FALSE, size);
429 }
430
431 /* Pop a type off the type stack. The caller is responsible for
432 freeing the string. */
433
434 static char *
stab_pop_type(struct stab_write_handle * info)435 stab_pop_type (struct stab_write_handle *info)
436 {
437 struct stab_type_stack *s;
438 char *ret;
439
440 s = info->type_stack;
441 assert (s != NULL);
442
443 info->type_stack = s->next;
444
445 ret = s->string;
446
447 free (s);
448
449 return ret;
450 }
451
452 /* The general routine to write out stabs in sections debugging
453 information. This accumulates the stabs symbols and the strings in
454 two obstacks. We can't easily write out the information as we go
455 along, because we need to know the section sizes before we can
456 write out the section contents. ABFD is the BFD and DHANDLE is the
457 handle for the debugging information. This sets *PSYMS to point to
458 the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the
459 strings, and *PSTRINGSIZE to the size of the strings. */
460
461 bfd_boolean
write_stabs_in_sections_debugging_info(bfd * abfd,void * dhandle,bfd_byte ** psyms,bfd_size_type * psymsize,bfd_byte ** pstrings,bfd_size_type * pstringsize)462 write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle,
463 bfd_byte **psyms,
464 bfd_size_type *psymsize,
465 bfd_byte **pstrings,
466 bfd_size_type *pstringsize)
467 {
468 struct stab_write_handle info;
469 struct string_hash_entry *h;
470 bfd_byte *p;
471
472 info.abfd = abfd;
473
474 info.symbols_size = 0;
475 info.symbols_alloc = 500;
476 info.symbols = (bfd_byte *) xmalloc (info.symbols_alloc);
477
478 info.strings = NULL;
479 info.last_string = NULL;
480 /* Reserve 1 byte for a null byte. */
481 info.strings_size = 1;
482
483 if (! bfd_hash_table_init (&info.strhash.table, string_hash_newfunc)
484 || ! bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc))
485 {
486 non_fatal ("bfd_hash_table_init_failed: %s",
487 bfd_errmsg (bfd_get_error ()));
488 return FALSE;
489 }
490
491 info.type_stack = NULL;
492 info.type_index = 1;
493 memset (&info.type_cache, 0, sizeof info.type_cache);
494 info.so_offset = -1;
495 info.fun_offset = -1;
496 info.last_text_address = 0;
497 info.nesting = 0;
498 info.fnaddr = 0;
499 info.pending_lbrac = (bfd_vma) -1;
500
501 /* The initial symbol holds the string size. */
502 if (! stab_write_symbol (&info, 0, 0, 0, (const char *) NULL))
503 return FALSE;
504
505 /* Output an initial N_SO symbol. */
506 info.so_offset = info.symbols_size;
507 if (! stab_write_symbol (&info, N_SO, 0, 0, bfd_get_filename (abfd)))
508 return FALSE;
509
510 if (! debug_write (dhandle, &stab_fns, (void *) &info))
511 return FALSE;
512
513 assert (info.pending_lbrac == (bfd_vma) -1);
514
515 /* Output a trailing N_SO. */
516 if (! stab_write_symbol (&info, N_SO, 0, info.last_text_address,
517 (const char *) NULL))
518 return FALSE;
519
520 /* Put the string size in the initial symbol. */
521 bfd_put_32 (abfd, info.strings_size, info.symbols + 8);
522
523 *psyms = info.symbols;
524 *psymsize = info.symbols_size;
525
526 *pstringsize = info.strings_size;
527 *pstrings = (bfd_byte *) xmalloc (info.strings_size);
528
529 p = *pstrings;
530 *p++ = '\0';
531 for (h = info.strings; h != NULL; h = h->next)
532 {
533 strcpy ((char *) p, h->root.string);
534 p += strlen ((char *) p) + 1;
535 }
536
537 return TRUE;
538 }
539
540 /* Start writing out information for a compilation unit. */
541
542 static bfd_boolean
stab_start_compilation_unit(void * p,const char * filename)543 stab_start_compilation_unit (void *p, const char *filename)
544 {
545 struct stab_write_handle *info = (struct stab_write_handle *) p;
546
547 /* We would normally output an N_SO symbol here. However, that
548 would force us to reset all of our type information. I think we
549 will be better off just outputting an N_SOL symbol, and not
550 worrying about splitting information between files. */
551
552 info->lineno_filename = filename;
553
554 return stab_write_symbol (info, N_SOL, 0, 0, filename);
555 }
556
557 /* Start writing out information for a particular source file. */
558
559 static bfd_boolean
stab_start_source(void * p,const char * filename)560 stab_start_source (void *p, const char *filename)
561 {
562 struct stab_write_handle *info = (struct stab_write_handle *) p;
563
564 /* FIXME: The symbol's value is supposed to be the text section
565 address. However, we would have to fill it in later, and gdb
566 doesn't care, so we don't bother with it. */
567
568 info->lineno_filename = filename;
569
570 return stab_write_symbol (info, N_SOL, 0, 0, filename);
571 }
572
573 /* Push an empty type. This shouldn't normally happen. We just use a
574 void type. */
575
576 static bfd_boolean
stab_empty_type(void * p)577 stab_empty_type (void *p)
578 {
579 struct stab_write_handle *info = (struct stab_write_handle *) p;
580
581 /* We don't call stab_void_type if the type is not yet defined,
582 because that might screw up the typedef. */
583
584 if (info->type_cache.void_type != 0)
585 return stab_push_defined_type (info, info->type_cache.void_type, 0);
586 else
587 {
588 long index;
589 char buf[40];
590
591 index = info->type_index;
592 ++info->type_index;
593
594 sprintf (buf, "%ld=%ld", index, index);
595
596 return stab_push_string (info, buf, index, FALSE, 0);
597 }
598 }
599
600 /* Push a void type. */
601
602 static bfd_boolean
stab_void_type(void * p)603 stab_void_type (void *p)
604 {
605 struct stab_write_handle *info = (struct stab_write_handle *) p;
606
607 if (info->type_cache.void_type != 0)
608 return stab_push_defined_type (info, info->type_cache.void_type, 0);
609 else
610 {
611 long index;
612 char buf[40];
613
614 index = info->type_index;
615 ++info->type_index;
616
617 info->type_cache.void_type = index;
618
619 sprintf (buf, "%ld=%ld", index, index);
620
621 return stab_push_string (info, buf, index, TRUE, 0);
622 }
623 }
624
625 /* Push an integer type. */
626
627 static bfd_boolean
stab_int_type(void * p,unsigned int size,bfd_boolean unsignedp)628 stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
629 {
630 struct stab_write_handle *info = (struct stab_write_handle *) p;
631 long *cache;
632
633 if (size <= 0 || (size > sizeof (long) && size != 8))
634 {
635 non_fatal (_("stab_int_type: bad size %u"), size);
636 return FALSE;
637 }
638
639 if (unsignedp)
640 cache = info->type_cache.signed_integer_types;
641 else
642 cache = info->type_cache.unsigned_integer_types;
643
644 if (cache[size - 1] != 0)
645 return stab_push_defined_type (info, cache[size - 1], size);
646 else
647 {
648 long index;
649 char buf[100];
650
651 index = info->type_index;
652 ++info->type_index;
653
654 cache[size - 1] = index;
655
656 sprintf (buf, "%ld=r%ld;", index, index);
657 if (unsignedp)
658 {
659 strcat (buf, "0;");
660 if (size < sizeof (long))
661 sprintf (buf + strlen (buf), "%ld;", ((long) 1 << (size * 8)) - 1);
662 else if (size == sizeof (long))
663 strcat (buf, "-1;");
664 else if (size == 8)
665 strcat (buf, "01777777777777777777777;");
666 else
667 abort ();
668 }
669 else
670 {
671 if (size <= sizeof (long))
672 sprintf (buf + strlen (buf), "%ld;%ld;",
673 (long) - ((unsigned long) 1 << (size * 8 - 1)),
674 (long) (((unsigned long) 1 << (size * 8 - 1)) - 1));
675 else if (size == 8)
676 strcat (buf, "01000000000000000000000;0777777777777777777777;");
677 else
678 abort ();
679 }
680
681 return stab_push_string (info, buf, index, TRUE, size);
682 }
683 }
684
685 /* Push a floating point type. */
686
687 static bfd_boolean
stab_float_type(void * p,unsigned int size)688 stab_float_type (void *p, unsigned int size)
689 {
690 struct stab_write_handle *info = (struct stab_write_handle *) p;
691
692 if (size > 0
693 && size - 1 < (sizeof info->type_cache.float_types
694 / sizeof info->type_cache.float_types[0])
695 && info->type_cache.float_types[size - 1] != 0)
696 return stab_push_defined_type (info,
697 info->type_cache.float_types[size - 1],
698 size);
699 else
700 {
701 long index;
702 char *int_type;
703 char buf[50];
704
705 /* Floats are defined as a subrange of int. */
706 if (! stab_int_type (info, 4, FALSE))
707 return FALSE;
708 int_type = stab_pop_type (info);
709
710 index = info->type_index;
711 ++info->type_index;
712
713 if (size > 0
714 && size - 1 < (sizeof info->type_cache.float_types
715 / sizeof info->type_cache.float_types[0]))
716 info->type_cache.float_types[size - 1] = index;
717
718 sprintf (buf, "%ld=r%s;%u;0;", index, int_type, size);
719
720 free (int_type);
721
722 return stab_push_string (info, buf, index, TRUE, size);
723 }
724 }
725
726 /* Push a complex type. */
727
728 static bfd_boolean
stab_complex_type(void * p,unsigned int size)729 stab_complex_type (void *p, unsigned int size)
730 {
731 struct stab_write_handle *info = (struct stab_write_handle *) p;
732 char buf[50];
733 long index;
734
735 index = info->type_index;
736 ++info->type_index;
737
738 sprintf (buf, "%ld=r%ld;%u;0;", index, index, size);
739
740 return stab_push_string (info, buf, index, TRUE, size * 2);
741 }
742
743 /* Push a bfd_boolean type. We use an XCOFF predefined type, since gdb
744 always recognizes them. */
745
746 static bfd_boolean
stab_bool_type(void * p,unsigned int size)747 stab_bool_type (void *p, unsigned int size)
748 {
749 struct stab_write_handle *info = (struct stab_write_handle *) p;
750 long index;
751
752 switch (size)
753 {
754 case 1:
755 index = -21;
756 break;
757
758 case 2:
759 index = -22;
760 break;
761
762 default:
763 case 4:
764 index = -16;
765 break;
766
767 case 8:
768 index = -33;
769 break;
770 }
771
772 return stab_push_defined_type (info, index, size);
773 }
774
775 /* Push an enum type. */
776
777 static bfd_boolean
stab_enum_type(void * p,const char * tag,const char ** names,bfd_signed_vma * vals)778 stab_enum_type (void *p, const char *tag, const char **names,
779 bfd_signed_vma *vals)
780 {
781 struct stab_write_handle *info = (struct stab_write_handle *) p;
782 size_t len;
783 const char **pn;
784 char *buf;
785 long index = 0;
786 bfd_signed_vma *pv;
787
788 if (names == NULL)
789 {
790 assert (tag != NULL);
791
792 buf = (char *) xmalloc (10 + strlen (tag));
793 sprintf (buf, "xe%s:", tag);
794 /* FIXME: The size is just a guess. */
795 if (! stab_push_string (info, buf, 0, FALSE, 4))
796 return FALSE;
797 free (buf);
798 return TRUE;
799 }
800
801 len = 10;
802 if (tag != NULL)
803 len += strlen (tag);
804 for (pn = names; *pn != NULL; pn++)
805 len += strlen (*pn) + 20;
806
807 buf = (char *) xmalloc (len);
808
809 if (tag == NULL)
810 strcpy (buf, "e");
811 else
812 {
813 index = info->type_index;
814 ++info->type_index;
815 sprintf (buf, "%s:T%ld=e", tag, index);
816 }
817
818 for (pn = names, pv = vals; *pn != NULL; pn++, pv++)
819 sprintf (buf + strlen (buf), "%s:%ld,", *pn, (long) *pv);
820 strcat (buf, ";");
821
822 if (tag == NULL)
823 {
824 /* FIXME: The size is just a guess. */
825 if (! stab_push_string (info, buf, 0, FALSE, 4))
826 return FALSE;
827 }
828 else
829 {
830 /* FIXME: The size is just a guess. */
831 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)
832 || ! stab_push_defined_type (info, index, 4))
833 return FALSE;
834 }
835
836 free (buf);
837
838 return TRUE;
839 }
840
841 /* Push a modification of the top type on the stack. Cache the
842 results in CACHE and CACHE_ALLOC. */
843
844 static bfd_boolean
stab_modify_type(struct stab_write_handle * info,int mod,unsigned int size,long ** cache,size_t * cache_alloc)845 stab_modify_type (struct stab_write_handle *info, int mod,
846 unsigned int size, long **cache, size_t *cache_alloc)
847 {
848 long targindex;
849 long index;
850 char *s, *buf;
851
852 assert (info->type_stack != NULL);
853 targindex = info->type_stack->index;
854
855 if (targindex <= 0
856 || cache == NULL)
857 {
858 bfd_boolean definition;
859
860 /* Either the target type has no index, or we aren't caching
861 this modifier. Either way we have no way of recording the
862 new type, so we don't bother to define one. */
863 definition = info->type_stack->definition;
864 s = stab_pop_type (info);
865 buf = (char *) xmalloc (strlen (s) + 2);
866 sprintf (buf, "%c%s", mod, s);
867 free (s);
868 if (! stab_push_string (info, buf, 0, definition, size))
869 return FALSE;
870 free (buf);
871 }
872 else
873 {
874 if ((size_t) targindex >= *cache_alloc)
875 {
876 size_t alloc;
877
878 alloc = *cache_alloc;
879 if (alloc == 0)
880 alloc = 10;
881 while ((size_t) targindex >= alloc)
882 alloc *= 2;
883 *cache = (long *) xrealloc (*cache, alloc * sizeof (long));
884 memset (*cache + *cache_alloc, 0,
885 (alloc - *cache_alloc) * sizeof (long));
886 *cache_alloc = alloc;
887 }
888
889 index = (*cache)[targindex];
890 if (index != 0 && ! info->type_stack->definition)
891 {
892 /* We have already defined a modification of this type, and
893 the entry on the type stack is not a definition, so we
894 can safely discard it (we may have a definition on the
895 stack, even if we already defined a modification, if it
896 is a struct which we did not define at the time it was
897 referenced). */
898 free (stab_pop_type (info));
899 if (! stab_push_defined_type (info, index, size))
900 return FALSE;
901 }
902 else
903 {
904 index = info->type_index;
905 ++info->type_index;
906
907 s = stab_pop_type (info);
908 buf = (char *) xmalloc (strlen (s) + 20);
909 sprintf (buf, "%ld=%c%s", index, mod, s);
910 free (s);
911
912 (*cache)[targindex] = index;
913
914 if (! stab_push_string (info, buf, index, TRUE, size))
915 return FALSE;
916
917 free (buf);
918 }
919 }
920
921 return TRUE;
922 }
923
924 /* Push a pointer type. */
925
926 static bfd_boolean
stab_pointer_type(void * p)927 stab_pointer_type (void *p)
928 {
929 struct stab_write_handle *info = (struct stab_write_handle *) p;
930
931 /* FIXME: The size should depend upon the architecture. */
932 return stab_modify_type (info, '*', 4, &info->type_cache.pointer_types,
933 &info->type_cache.pointer_types_alloc);
934 }
935
936 /* Push a function type. */
937
938 static bfd_boolean
stab_function_type(void * p,int argcount,bfd_boolean varargs ATTRIBUTE_UNUSED)939 stab_function_type (void *p, int argcount,
940 bfd_boolean varargs ATTRIBUTE_UNUSED)
941 {
942 struct stab_write_handle *info = (struct stab_write_handle *) p;
943 int i;
944
945 /* We have no way to represent the argument types, so we just
946 discard them. However, if they define new types, we must output
947 them. We do this by producing empty typedefs. */
948 for (i = 0; i < argcount; i++)
949 {
950 if (! info->type_stack->definition)
951 free (stab_pop_type (info));
952 else
953 {
954 char *s, *buf;
955
956 s = stab_pop_type (info);
957
958 buf = (char *) xmalloc (strlen (s) + 3);
959 sprintf (buf, ":t%s", s);
960 free (s);
961
962 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
963 return FALSE;
964
965 free (buf);
966 }
967 }
968
969 return stab_modify_type (info, 'f', 0, &info->type_cache.function_types,
970 &info->type_cache.function_types_alloc);
971 }
972
973 /* Push a reference type. */
974
975 static bfd_boolean
stab_reference_type(void * p)976 stab_reference_type (void *p)
977 {
978 struct stab_write_handle *info = (struct stab_write_handle *) p;
979
980 /* FIXME: The size should depend upon the architecture. */
981 return stab_modify_type (info, '&', 4, &info->type_cache.reference_types,
982 &info->type_cache.reference_types_alloc);
983 }
984
985 /* Push a range type. */
986
987 static bfd_boolean
stab_range_type(void * p,bfd_signed_vma low,bfd_signed_vma high)988 stab_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
989 {
990 struct stab_write_handle *info = (struct stab_write_handle *) p;
991 bfd_boolean definition;
992 unsigned int size;
993 char *s, *buf;
994
995 definition = info->type_stack->definition;
996 size = info->type_stack->size;
997
998 s = stab_pop_type (info);
999 buf = (char *) xmalloc (strlen (s) + 100);
1000 sprintf (buf, "r%s;%ld;%ld;", s, (long) low, (long) high);
1001 free (s);
1002
1003 if (! stab_push_string (info, buf, 0, definition, size))
1004 return FALSE;
1005
1006 free (buf);
1007
1008 return TRUE;
1009 }
1010
1011 /* Push an array type. */
1012
1013 static bfd_boolean
stab_array_type(void * p,bfd_signed_vma low,bfd_signed_vma high,bfd_boolean stringp)1014 stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
1015 bfd_boolean stringp)
1016 {
1017 struct stab_write_handle *info = (struct stab_write_handle *) p;
1018 bfd_boolean definition;
1019 unsigned int element_size;
1020 char *range, *element, *buf;
1021 long index;
1022 unsigned int size;
1023
1024 definition = info->type_stack->definition;
1025 range = stab_pop_type (info);
1026
1027 definition = definition || info->type_stack->definition;
1028 element_size = info->type_stack->size;
1029 element = stab_pop_type (info);
1030
1031 buf = (char *) xmalloc (strlen (range) + strlen (element) + 100);
1032
1033 if (! stringp)
1034 {
1035 index = 0;
1036 *buf = '\0';
1037 }
1038 else
1039 {
1040 /* We need to define a type in order to include the string
1041 attribute. */
1042 index = info->type_index;
1043 ++info->type_index;
1044 definition = TRUE;
1045 sprintf (buf, "%ld=@S;", index);
1046 }
1047
1048 sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s",
1049 range, (long) low, (long) high, element);
1050 free (range);
1051 free (element);
1052
1053 if (high < low)
1054 size = 0;
1055 else
1056 size = element_size * ((high - low) + 1);
1057 if (! stab_push_string (info, buf, index, definition, size))
1058 return FALSE;
1059
1060 free (buf);
1061
1062 return TRUE;
1063 }
1064
1065 /* Push a set type. */
1066
1067 static bfd_boolean
stab_set_type(void * p,bfd_boolean bitstringp)1068 stab_set_type (void *p, bfd_boolean bitstringp)
1069 {
1070 struct stab_write_handle *info = (struct stab_write_handle *) p;
1071 bfd_boolean definition;
1072 char *s, *buf;
1073 long index;
1074
1075 definition = info->type_stack->definition;
1076
1077 s = stab_pop_type (info);
1078 buf = (char *) xmalloc (strlen (s) + 30);
1079
1080 if (! bitstringp)
1081 {
1082 *buf = '\0';
1083 index = 0;
1084 }
1085 else
1086 {
1087 /* We need to define a type in order to include the string
1088 attribute. */
1089 index = info->type_index;
1090 ++info->type_index;
1091 definition = TRUE;
1092 sprintf (buf, "%ld=@S;", index);
1093 }
1094
1095 sprintf (buf + strlen (buf), "S%s", s);
1096 free (s);
1097
1098 if (! stab_push_string (info, buf, index, definition, 0))
1099 return FALSE;
1100
1101 free (buf);
1102
1103 return TRUE;
1104 }
1105
1106 /* Push an offset type. */
1107
1108 static bfd_boolean
stab_offset_type(void * p)1109 stab_offset_type (void *p)
1110 {
1111 struct stab_write_handle *info = (struct stab_write_handle *) p;
1112 bfd_boolean definition;
1113 char *target, *base, *buf;
1114
1115 definition = info->type_stack->definition;
1116 target = stab_pop_type (info);
1117
1118 definition = definition || info->type_stack->definition;
1119 base = stab_pop_type (info);
1120
1121 buf = (char *) xmalloc (strlen (target) + strlen (base) + 3);
1122 sprintf (buf, "@%s,%s", base, target);
1123 free (base);
1124 free (target);
1125
1126 if (! stab_push_string (info, buf, 0, definition, 0))
1127 return FALSE;
1128
1129 free (buf);
1130
1131 return TRUE;
1132 }
1133
1134 /* Push a method type. */
1135
1136 static bfd_boolean
stab_method_type(void * p,bfd_boolean domainp,int argcount,bfd_boolean varargs)1137 stab_method_type (void *p, bfd_boolean domainp, int argcount,
1138 bfd_boolean varargs)
1139 {
1140 struct stab_write_handle *info = (struct stab_write_handle *) p;
1141 bfd_boolean definition;
1142 char *domain, *return_type, *buf;
1143 char **args;
1144 int i;
1145 size_t len;
1146
1147 /* We don't bother with stub method types, because that would
1148 require a mangler for C++ argument types. This will waste space
1149 in the debugging output. */
1150
1151 /* We need a domain. I'm not sure DOMAINP can ever be false,
1152 anyhow. */
1153 if (! domainp)
1154 {
1155 if (! stab_empty_type (p))
1156 return FALSE;
1157 }
1158
1159 definition = info->type_stack->definition;
1160 domain = stab_pop_type (info);
1161
1162 /* A non-varargs function is indicated by making the last parameter
1163 type be void. */
1164
1165 if (argcount < 0)
1166 {
1167 args = NULL;
1168 argcount = 0;
1169 }
1170 else if (argcount == 0)
1171 {
1172 if (varargs)
1173 args = NULL;
1174 else
1175 {
1176 args = (char **) xmalloc (1 * sizeof (*args));
1177 if (! stab_empty_type (p))
1178 return FALSE;
1179 definition = definition || info->type_stack->definition;
1180 args[0] = stab_pop_type (info);
1181 argcount = 1;
1182 }
1183 }
1184 else
1185 {
1186 args = (char **) xmalloc ((argcount + 1) * sizeof (*args));
1187 for (i = argcount - 1; i >= 0; i--)
1188 {
1189 definition = definition || info->type_stack->definition;
1190 args[i] = stab_pop_type (info);
1191 }
1192 if (! varargs)
1193 {
1194 if (! stab_empty_type (p))
1195 return FALSE;
1196 definition = definition || info->type_stack->definition;
1197 args[argcount] = stab_pop_type (info);
1198 ++argcount;
1199 }
1200 }
1201
1202 definition = definition || info->type_stack->definition;
1203 return_type = stab_pop_type (info);
1204
1205 len = strlen (domain) + strlen (return_type) + 10;
1206 for (i = 0; i < argcount; i++)
1207 len += strlen (args[i]);
1208
1209 buf = (char *) xmalloc (len);
1210
1211 sprintf (buf, "#%s,%s", domain, return_type);
1212 free (domain);
1213 free (return_type);
1214 for (i = 0; i < argcount; i++)
1215 {
1216 strcat (buf, ",");
1217 strcat (buf, args[i]);
1218 free (args[i]);
1219 }
1220 strcat (buf, ";");
1221
1222 if (args != NULL)
1223 free (args);
1224
1225 if (! stab_push_string (info, buf, 0, definition, 0))
1226 return FALSE;
1227
1228 free (buf);
1229
1230 return TRUE;
1231 }
1232
1233 /* Push a const version of a type. */
1234
1235 static bfd_boolean
stab_const_type(void * p)1236 stab_const_type (void *p)
1237 {
1238 struct stab_write_handle *info = (struct stab_write_handle *) p;
1239
1240 return stab_modify_type (info, 'k', info->type_stack->size,
1241 (long **) NULL, (size_t *) NULL);
1242 }
1243
1244 /* Push a volatile version of a type. */
1245
1246 static bfd_boolean
stab_volatile_type(void * p)1247 stab_volatile_type (void *p)
1248 {
1249 struct stab_write_handle *info = (struct stab_write_handle *) p;
1250
1251 return stab_modify_type (info, 'B', info->type_stack->size,
1252 (long **) NULL, (size_t *) NULL);
1253 }
1254
1255 /* Get the type index to use for a struct/union/class ID. This should
1256 return -1 if it fails. */
1257
1258 static long
stab_get_struct_index(struct stab_write_handle * info,const char * tag,unsigned int id,enum debug_type_kind kind,unsigned int * psize)1259 stab_get_struct_index (struct stab_write_handle *info, const char *tag,
1260 unsigned int id, enum debug_type_kind kind,
1261 unsigned int *psize)
1262 {
1263 if (id >= info->type_cache.struct_types_alloc)
1264 {
1265 size_t alloc;
1266
1267 alloc = info->type_cache.struct_types_alloc;
1268 if (alloc == 0)
1269 alloc = 10;
1270 while (id >= alloc)
1271 alloc *= 2;
1272 info->type_cache.struct_types =
1273 (struct stab_tag *) xrealloc (info->type_cache.struct_types,
1274 alloc * sizeof (struct stab_tag));
1275 memset ((info->type_cache.struct_types
1276 + info->type_cache.struct_types_alloc),
1277 0,
1278 ((alloc - info->type_cache.struct_types_alloc)
1279 * sizeof (struct stab_tag)));
1280 info->type_cache.struct_types_alloc = alloc;
1281 }
1282
1283 if (info->type_cache.struct_types[id].index == 0)
1284 {
1285 info->type_cache.struct_types[id].index = info->type_index;
1286 ++info->type_index;
1287 info->type_cache.struct_types[id].tag = tag;
1288 info->type_cache.struct_types[id].kind = kind;
1289 }
1290
1291 if (kind == DEBUG_KIND_ILLEGAL)
1292 {
1293 /* This is a definition of the struct. */
1294 info->type_cache.struct_types[id].kind = kind;
1295 info->type_cache.struct_types[id].size = *psize;
1296 }
1297 else
1298 *psize = info->type_cache.struct_types[id].size;
1299
1300 return info->type_cache.struct_types[id].index;
1301 }
1302
1303 /* Start outputting a struct. We ignore the tag, and handle it in
1304 stab_tag. */
1305
1306 static bfd_boolean
stab_start_struct_type(void * p,const char * tag,unsigned int id,bfd_boolean structp,unsigned int size)1307 stab_start_struct_type (void *p, const char *tag, unsigned int id,
1308 bfd_boolean structp, unsigned int size)
1309 {
1310 struct stab_write_handle *info = (struct stab_write_handle *) p;
1311 long index;
1312 bfd_boolean definition;
1313 char *buf;
1314
1315 buf = (char *) xmalloc (40);
1316
1317 if (id == 0)
1318 {
1319 index = 0;
1320 *buf = '\0';
1321 definition = FALSE;
1322 }
1323 else
1324 {
1325 index = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
1326 &size);
1327 if (index < 0)
1328 return FALSE;
1329 sprintf (buf, "%ld=", index);
1330 definition = TRUE;
1331 }
1332
1333 sprintf (buf + strlen (buf), "%c%u",
1334 structp ? 's' : 'u',
1335 size);
1336
1337 if (! stab_push_string (info, buf, index, definition, size))
1338 return FALSE;
1339
1340 info->type_stack->fields = (char *) xmalloc (1);
1341 info->type_stack->fields[0] = '\0';
1342
1343 return TRUE;
1344 }
1345
1346 /* Add a field to a struct. */
1347
1348 static bfd_boolean
stab_struct_field(void * p,const char * name,bfd_vma bitpos,bfd_vma bitsize,enum debug_visibility visibility)1349 stab_struct_field (void *p, const char *name, bfd_vma bitpos,
1350 bfd_vma bitsize, enum debug_visibility visibility)
1351 {
1352 struct stab_write_handle *info = (struct stab_write_handle *) p;
1353 bfd_boolean definition;
1354 unsigned int size;
1355 char *s, *n;
1356 const char *vis;
1357
1358 definition = info->type_stack->definition;
1359 size = info->type_stack->size;
1360 s = stab_pop_type (info);
1361
1362 /* Add this field to the end of the current struct fields, which is
1363 currently on the top of the stack. */
1364
1365 assert (info->type_stack->fields != NULL);
1366 n = (char *) xmalloc (strlen (info->type_stack->fields)
1367 + strlen (name)
1368 + strlen (s)
1369 + 50);
1370
1371 switch (visibility)
1372 {
1373 default:
1374 abort ();
1375
1376 case DEBUG_VISIBILITY_PUBLIC:
1377 vis = "";
1378 break;
1379
1380 case DEBUG_VISIBILITY_PRIVATE:
1381 vis = "/0";
1382 break;
1383
1384 case DEBUG_VISIBILITY_PROTECTED:
1385 vis = "/1";
1386 break;
1387 }
1388
1389 if (bitsize == 0)
1390 {
1391 bitsize = size * 8;
1392 if (bitsize == 0)
1393 non_fatal (_("%s: warning: unknown size for field `%s' in struct"),
1394 bfd_get_filename (info->abfd), name);
1395 }
1396
1397 sprintf (n, "%s%s:%s%s,%ld,%ld;", info->type_stack->fields, name, vis, s,
1398 (long) bitpos, (long) bitsize);
1399
1400 free (info->type_stack->fields);
1401 info->type_stack->fields = n;
1402
1403 if (definition)
1404 info->type_stack->definition = TRUE;
1405
1406 return TRUE;
1407 }
1408
1409 /* Finish up a struct. */
1410
1411 static bfd_boolean
stab_end_struct_type(void * p)1412 stab_end_struct_type (void *p)
1413 {
1414 struct stab_write_handle *info = (struct stab_write_handle *) p;
1415 bfd_boolean definition;
1416 long index;
1417 unsigned int size;
1418 char *fields, *first, *buf;
1419
1420 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1421
1422 definition = info->type_stack->definition;
1423 index = info->type_stack->index;
1424 size = info->type_stack->size;
1425 fields = info->type_stack->fields;
1426 first = stab_pop_type (info);
1427
1428 buf = (char *) xmalloc (strlen (first) + strlen (fields) + 2);
1429 sprintf (buf, "%s%s;", first, fields);
1430 free (first);
1431 free (fields);
1432
1433 if (! stab_push_string (info, buf, index, definition, size))
1434 return FALSE;
1435
1436 free (buf);
1437
1438 return TRUE;
1439 }
1440
1441 /* Start outputting a class. */
1442
1443 static bfd_boolean
stab_start_class_type(void * p,const char * tag,unsigned int id,bfd_boolean structp,unsigned int size,bfd_boolean vptr,bfd_boolean ownvptr)1444 stab_start_class_type (void *p, const char *tag, unsigned int id, bfd_boolean structp, unsigned int size, bfd_boolean vptr, bfd_boolean ownvptr)
1445 {
1446 struct stab_write_handle *info = (struct stab_write_handle *) p;
1447 bfd_boolean definition;
1448 char *vstring;
1449
1450 if (! vptr || ownvptr)
1451 {
1452 definition = FALSE;
1453 vstring = NULL;
1454 }
1455 else
1456 {
1457 definition = info->type_stack->definition;
1458 vstring = stab_pop_type (info);
1459 }
1460
1461 if (! stab_start_struct_type (p, tag, id, structp, size))
1462 return FALSE;
1463
1464 if (vptr)
1465 {
1466 char *vtable;
1467
1468 if (ownvptr)
1469 {
1470 assert (info->type_stack->index > 0);
1471 vtable = (char *) xmalloc (20);
1472 sprintf (vtable, "~%%%ld", info->type_stack->index);
1473 }
1474 else
1475 {
1476 vtable = (char *) xmalloc (strlen (vstring) + 3);
1477 sprintf (vtable, "~%%%s", vstring);
1478 free (vstring);
1479 }
1480
1481 info->type_stack->vtable = vtable;
1482 }
1483
1484 if (definition)
1485 info->type_stack->definition = TRUE;
1486
1487 return TRUE;
1488 }
1489
1490 /* Add a static member to the class on the type stack. */
1491
1492 static bfd_boolean
stab_class_static_member(void * p,const char * name,const char * physname,enum debug_visibility visibility)1493 stab_class_static_member (void *p, const char *name, const char *physname,
1494 enum debug_visibility visibility)
1495 {
1496 struct stab_write_handle *info = (struct stab_write_handle *) p;
1497 bfd_boolean definition;
1498 char *s, *n;
1499 const char *vis;
1500
1501 definition = info->type_stack->definition;
1502 s = stab_pop_type (info);
1503
1504 /* Add this field to the end of the current struct fields, which is
1505 currently on the top of the stack. */
1506
1507 assert (info->type_stack->fields != NULL);
1508 n = (char *) xmalloc (strlen (info->type_stack->fields)
1509 + strlen (name)
1510 + strlen (s)
1511 + strlen (physname)
1512 + 10);
1513
1514 switch (visibility)
1515 {
1516 default:
1517 abort ();
1518
1519 case DEBUG_VISIBILITY_PUBLIC:
1520 vis = "";
1521 break;
1522
1523 case DEBUG_VISIBILITY_PRIVATE:
1524 vis = "/0";
1525 break;
1526
1527 case DEBUG_VISIBILITY_PROTECTED:
1528 vis = "/1";
1529 break;
1530 }
1531
1532 sprintf (n, "%s%s:%s%s:%s;", info->type_stack->fields, name, vis, s,
1533 physname);
1534
1535 free (info->type_stack->fields);
1536 info->type_stack->fields = n;
1537
1538 if (definition)
1539 info->type_stack->definition = TRUE;
1540
1541 return TRUE;
1542 }
1543
1544 /* Add a base class to the class on the type stack. */
1545
1546 static bfd_boolean
stab_class_baseclass(void * p,bfd_vma bitpos,bfd_boolean virtual,enum debug_visibility visibility)1547 stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
1548 enum debug_visibility visibility)
1549 {
1550 struct stab_write_handle *info = (struct stab_write_handle *) p;
1551 bfd_boolean definition;
1552 char *s;
1553 char *buf;
1554 unsigned int c;
1555 char **baseclasses;
1556
1557 definition = info->type_stack->definition;
1558 s = stab_pop_type (info);
1559
1560 /* Build the base class specifier. */
1561
1562 buf = (char *) xmalloc (strlen (s) + 25);
1563 buf[0] = virtual ? '1' : '0';
1564 switch (visibility)
1565 {
1566 default:
1567 abort ();
1568
1569 case DEBUG_VISIBILITY_PRIVATE:
1570 buf[1] = '0';
1571 break;
1572
1573 case DEBUG_VISIBILITY_PROTECTED:
1574 buf[1] = '1';
1575 break;
1576
1577 case DEBUG_VISIBILITY_PUBLIC:
1578 buf[1] = '2';
1579 break;
1580 }
1581
1582 sprintf (buf + 2, "%ld,%s;", (long) bitpos, s);
1583 free (s);
1584
1585 /* Add the new baseclass to the existing ones. */
1586
1587 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1588
1589 if (info->type_stack->baseclasses == NULL)
1590 c = 0;
1591 else
1592 {
1593 c = 0;
1594 while (info->type_stack->baseclasses[c] != NULL)
1595 ++c;
1596 }
1597
1598 baseclasses = (char **) xrealloc (info->type_stack->baseclasses,
1599 (c + 2) * sizeof (*baseclasses));
1600 baseclasses[c] = buf;
1601 baseclasses[c + 1] = NULL;
1602
1603 info->type_stack->baseclasses = baseclasses;
1604
1605 if (definition)
1606 info->type_stack->definition = TRUE;
1607
1608 return TRUE;
1609 }
1610
1611 /* Start adding a method to the class on the type stack. */
1612
1613 static bfd_boolean
stab_class_start_method(void * p,const char * name)1614 stab_class_start_method (void *p, const char *name)
1615 {
1616 struct stab_write_handle *info = (struct stab_write_handle *) p;
1617 char *m;
1618
1619 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1620
1621 if (info->type_stack->methods == NULL)
1622 {
1623 m = (char *) xmalloc (strlen (name) + 3);
1624 *m = '\0';
1625 }
1626 else
1627 {
1628 m = (char *) xrealloc (info->type_stack->methods,
1629 (strlen (info->type_stack->methods)
1630 + strlen (name)
1631 + 4));
1632 }
1633
1634 sprintf (m + strlen (m), "%s::", name);
1635
1636 info->type_stack->methods = m;
1637
1638 return TRUE;
1639 }
1640
1641 /* Add a variant, either static or not, to the current method. */
1642
1643 static bfd_boolean
stab_class_method_var(struct stab_write_handle * info,const char * physname,enum debug_visibility visibility,bfd_boolean staticp,bfd_boolean constp,bfd_boolean volatilep,bfd_vma voffset,bfd_boolean contextp)1644 stab_class_method_var (struct stab_write_handle *info, const char *physname,
1645 enum debug_visibility visibility,
1646 bfd_boolean staticp, bfd_boolean constp,
1647 bfd_boolean volatilep, bfd_vma voffset,
1648 bfd_boolean contextp)
1649 {
1650 bfd_boolean definition;
1651 char *type;
1652 char *context = NULL;
1653 char visc, qualc, typec;
1654
1655 definition = info->type_stack->definition;
1656 type = stab_pop_type (info);
1657
1658 if (contextp)
1659 {
1660 definition = definition || info->type_stack->definition;
1661 context = stab_pop_type (info);
1662 }
1663
1664 assert (info->type_stack != NULL && info->type_stack->methods != NULL);
1665
1666 switch (visibility)
1667 {
1668 default:
1669 abort ();
1670
1671 case DEBUG_VISIBILITY_PRIVATE:
1672 visc = '0';
1673 break;
1674
1675 case DEBUG_VISIBILITY_PROTECTED:
1676 visc = '1';
1677 break;
1678
1679 case DEBUG_VISIBILITY_PUBLIC:
1680 visc = '2';
1681 break;
1682 }
1683
1684 if (constp)
1685 {
1686 if (volatilep)
1687 qualc = 'D';
1688 else
1689 qualc = 'B';
1690 }
1691 else
1692 {
1693 if (volatilep)
1694 qualc = 'C';
1695 else
1696 qualc = 'A';
1697 }
1698
1699 if (staticp)
1700 typec = '?';
1701 else if (! contextp)
1702 typec = '.';
1703 else
1704 typec = '*';
1705
1706 info->type_stack->methods =
1707 (char *) xrealloc (info->type_stack->methods,
1708 (strlen (info->type_stack->methods)
1709 + strlen (type)
1710 + strlen (physname)
1711 + (contextp ? strlen (context) : 0)
1712 + 40));
1713
1714 sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
1715 "%s:%s;%c%c%c", type, physname, visc, qualc, typec);
1716 free (type);
1717
1718 if (contextp)
1719 {
1720 sprintf (info->type_stack->methods + strlen (info->type_stack->methods),
1721 "%ld;%s;", (long) voffset, context);
1722 free (context);
1723 }
1724
1725 if (definition)
1726 info->type_stack->definition = TRUE;
1727
1728 return TRUE;
1729 }
1730
1731 /* Add a variant to the current method. */
1732
1733 static bfd_boolean
stab_class_method_variant(void * p,const char * physname,enum debug_visibility visibility,bfd_boolean constp,bfd_boolean volatilep,bfd_vma voffset,bfd_boolean contextp)1734 stab_class_method_variant (void *p, const char *physname,
1735 enum debug_visibility visibility,
1736 bfd_boolean constp, bfd_boolean volatilep,
1737 bfd_vma voffset, bfd_boolean contextp)
1738 {
1739 struct stab_write_handle *info = (struct stab_write_handle *) p;
1740
1741 return stab_class_method_var (info, physname, visibility, FALSE, constp,
1742 volatilep, voffset, contextp);
1743 }
1744
1745 /* Add a static variant to the current method. */
1746
1747 static bfd_boolean
stab_class_static_method_variant(void * p,const char * physname,enum debug_visibility visibility,bfd_boolean constp,bfd_boolean volatilep)1748 stab_class_static_method_variant (void *p, const char *physname,
1749 enum debug_visibility visibility,
1750 bfd_boolean constp, bfd_boolean volatilep)
1751 {
1752 struct stab_write_handle *info = (struct stab_write_handle *) p;
1753
1754 return stab_class_method_var (info, physname, visibility, TRUE, constp,
1755 volatilep, 0, FALSE);
1756 }
1757
1758 /* Finish up a method. */
1759
1760 static bfd_boolean
stab_class_end_method(void * p)1761 stab_class_end_method (void *p)
1762 {
1763 struct stab_write_handle *info = (struct stab_write_handle *) p;
1764
1765 assert (info->type_stack != NULL && info->type_stack->methods != NULL);
1766
1767 /* We allocated enough room on info->type_stack->methods to add the
1768 trailing semicolon. */
1769 strcat (info->type_stack->methods, ";");
1770
1771 return TRUE;
1772 }
1773
1774 /* Finish up a class. */
1775
1776 static bfd_boolean
stab_end_class_type(void * p)1777 stab_end_class_type (void *p)
1778 {
1779 struct stab_write_handle *info = (struct stab_write_handle *) p;
1780 size_t len;
1781 unsigned int i = 0;
1782 char *buf;
1783
1784 assert (info->type_stack != NULL && info->type_stack->fields != NULL);
1785
1786 /* Work out the size we need to allocate for the class definition. */
1787
1788 len = (strlen (info->type_stack->string)
1789 + strlen (info->type_stack->fields)
1790 + 10);
1791 if (info->type_stack->baseclasses != NULL)
1792 {
1793 len += 20;
1794 for (i = 0; info->type_stack->baseclasses[i] != NULL; i++)
1795 len += strlen (info->type_stack->baseclasses[i]);
1796 }
1797 if (info->type_stack->methods != NULL)
1798 len += strlen (info->type_stack->methods);
1799 if (info->type_stack->vtable != NULL)
1800 len += strlen (info->type_stack->vtable);
1801
1802 /* Build the class definition. */
1803
1804 buf = (char *) xmalloc (len);
1805
1806 strcpy (buf, info->type_stack->string);
1807
1808 if (info->type_stack->baseclasses != NULL)
1809 {
1810 sprintf (buf + strlen (buf), "!%u,", i);
1811 for (i = 0; info->type_stack->baseclasses[i] != NULL; i++)
1812 {
1813 strcat (buf, info->type_stack->baseclasses[i]);
1814 free (info->type_stack->baseclasses[i]);
1815 }
1816 free (info->type_stack->baseclasses);
1817 info->type_stack->baseclasses = NULL;
1818 }
1819
1820 strcat (buf, info->type_stack->fields);
1821 free (info->type_stack->fields);
1822 info->type_stack->fields = NULL;
1823
1824 if (info->type_stack->methods != NULL)
1825 {
1826 strcat (buf, info->type_stack->methods);
1827 free (info->type_stack->methods);
1828 info->type_stack->methods = NULL;
1829 }
1830
1831 strcat (buf, ";");
1832
1833 if (info->type_stack->vtable != NULL)
1834 {
1835 strcat (buf, info->type_stack->vtable);
1836 free (info->type_stack->vtable);
1837 info->type_stack->vtable = NULL;
1838 }
1839
1840 /* Replace the string on the top of the stack with the complete
1841 class definition. */
1842 free (info->type_stack->string);
1843 info->type_stack->string = buf;
1844
1845 return TRUE;
1846 }
1847
1848 /* Push a typedef which was previously defined. */
1849
1850 static bfd_boolean
stab_typedef_type(void * p,const char * name)1851 stab_typedef_type (void *p, const char *name)
1852 {
1853 struct stab_write_handle *info = (struct stab_write_handle *) p;
1854 struct string_hash_entry *h;
1855
1856 h = string_hash_lookup (&info->typedef_hash, name, FALSE, FALSE);
1857 assert (h != NULL && h->index > 0);
1858
1859 return stab_push_defined_type (info, h->index, h->size);
1860 }
1861
1862 /* Push a struct, union or class tag. */
1863
1864 static bfd_boolean
stab_tag_type(void * p,const char * name,unsigned int id,enum debug_type_kind kind)1865 stab_tag_type (void *p, const char *name, unsigned int id,
1866 enum debug_type_kind kind)
1867 {
1868 struct stab_write_handle *info = (struct stab_write_handle *) p;
1869 long index;
1870 unsigned int size;
1871
1872 index = stab_get_struct_index (info, name, id, kind, &size);
1873 if (index < 0)
1874 return FALSE;
1875
1876 return stab_push_defined_type (info, index, size);
1877 }
1878
1879 /* Define a typedef. */
1880
1881 static bfd_boolean
stab_typdef(void * p,const char * name)1882 stab_typdef (void *p, const char *name)
1883 {
1884 struct stab_write_handle *info = (struct stab_write_handle *) p;
1885 long index;
1886 unsigned int size;
1887 char *s, *buf;
1888 struct string_hash_entry *h;
1889
1890 index = info->type_stack->index;
1891 size = info->type_stack->size;
1892 s = stab_pop_type (info);
1893
1894 buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
1895
1896 if (index > 0)
1897 sprintf (buf, "%s:t%s", name, s);
1898 else
1899 {
1900 index = info->type_index;
1901 ++info->type_index;
1902 sprintf (buf, "%s:t%ld=%s", name, index, s);
1903 }
1904
1905 free (s);
1906
1907 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1908 return FALSE;
1909
1910 free (buf);
1911
1912 h = string_hash_lookup (&info->typedef_hash, name, TRUE, FALSE);
1913 if (h == NULL)
1914 {
1915 non_fatal (_("string_hash_lookup failed: %s"),
1916 bfd_errmsg (bfd_get_error ()));
1917 return FALSE;
1918 }
1919
1920 /* I don't think we care about redefinitions. */
1921
1922 h->index = index;
1923 h->size = size;
1924
1925 return TRUE;
1926 }
1927
1928 /* Define a tag. */
1929
1930 static bfd_boolean
stab_tag(void * p,const char * tag)1931 stab_tag (void *p, const char *tag)
1932 {
1933 struct stab_write_handle *info = (struct stab_write_handle *) p;
1934 char *s, *buf;
1935
1936 s = stab_pop_type (info);
1937
1938 buf = (char *) xmalloc (strlen (tag) + strlen (s) + 3);
1939
1940 sprintf (buf, "%s:T%s", tag, s);
1941 free (s);
1942
1943 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1944 return FALSE;
1945
1946 free (buf);
1947
1948 return TRUE;
1949 }
1950
1951 /* Define an integer constant. */
1952
1953 static bfd_boolean
stab_int_constant(void * p,const char * name,bfd_vma val)1954 stab_int_constant (void *p, const char *name, bfd_vma val)
1955 {
1956 struct stab_write_handle *info = (struct stab_write_handle *) p;
1957 char *buf;
1958
1959 buf = (char *) xmalloc (strlen (name) + 20);
1960 sprintf (buf, "%s:c=i%ld", name, (long) val);
1961
1962 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1963 return FALSE;
1964
1965 free (buf);
1966
1967 return TRUE;
1968 }
1969
1970 /* Define a floating point constant. */
1971
1972 static bfd_boolean
stab_float_constant(void * p,const char * name,double val)1973 stab_float_constant (void *p, const char *name, double val)
1974 {
1975 struct stab_write_handle *info = (struct stab_write_handle *) p;
1976 char *buf;
1977
1978 buf = (char *) xmalloc (strlen (name) + 20);
1979 sprintf (buf, "%s:c=f%g", name, val);
1980
1981 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
1982 return FALSE;
1983
1984 free (buf);
1985
1986 return TRUE;
1987 }
1988
1989 /* Define a typed constant. */
1990
1991 static bfd_boolean
stab_typed_constant(void * p,const char * name,bfd_vma val)1992 stab_typed_constant (void *p, const char *name, bfd_vma val)
1993 {
1994 struct stab_write_handle *info = (struct stab_write_handle *) p;
1995 char *s, *buf;
1996
1997 s = stab_pop_type (info);
1998
1999 buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
2000 sprintf (buf, "%s:c=e%s,%ld", name, s, (long) val);
2001 free (s);
2002
2003 if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
2004 return FALSE;
2005
2006 free (buf);
2007
2008 return TRUE;
2009 }
2010
2011 /* Record a variable. */
2012
2013 static bfd_boolean
stab_variable(void * p,const char * name,enum debug_var_kind kind,bfd_vma val)2014 stab_variable (void *p, const char *name, enum debug_var_kind kind,
2015 bfd_vma val)
2016 {
2017 struct stab_write_handle *info = (struct stab_write_handle *) p;
2018 char *s, *buf;
2019 int stab_type;
2020 const char *kindstr;
2021
2022 s = stab_pop_type (info);
2023
2024 switch (kind)
2025 {
2026 default:
2027 abort ();
2028
2029 case DEBUG_GLOBAL:
2030 stab_type = N_GSYM;
2031 kindstr = "G";
2032 break;
2033
2034 case DEBUG_STATIC:
2035 stab_type = N_STSYM;
2036 kindstr = "S";
2037 break;
2038
2039 case DEBUG_LOCAL_STATIC:
2040 stab_type = N_STSYM;
2041 kindstr = "V";
2042 break;
2043
2044 case DEBUG_LOCAL:
2045 stab_type = N_LSYM;
2046 kindstr = "";
2047
2048 /* Make sure that this is a type reference or definition. */
2049 if (! ISDIGIT (*s))
2050 {
2051 char *n;
2052 long index;
2053
2054 index = info->type_index;
2055 ++info->type_index;
2056 n = (char *) xmalloc (strlen (s) + 20);
2057 sprintf (n, "%ld=%s", index, s);
2058 free (s);
2059 s = n;
2060 }
2061 break;
2062
2063 case DEBUG_REGISTER:
2064 stab_type = N_RSYM;
2065 kindstr = "r";
2066 break;
2067 }
2068
2069 buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
2070 sprintf (buf, "%s:%s%s", name, kindstr, s);
2071 free (s);
2072
2073 if (! stab_write_symbol (info, stab_type, 0, val, buf))
2074 return FALSE;
2075
2076 free (buf);
2077
2078 return TRUE;
2079 }
2080
2081 /* Start outputting a function. */
2082
2083 static bfd_boolean
stab_start_function(void * p,const char * name,bfd_boolean globalp)2084 stab_start_function (void *p, const char *name, bfd_boolean globalp)
2085 {
2086 struct stab_write_handle *info = (struct stab_write_handle *) p;
2087 char *rettype, *buf;
2088
2089 assert (info->nesting == 0 && info->fun_offset == -1);
2090
2091 rettype = stab_pop_type (info);
2092
2093 buf = (char *) xmalloc (strlen (name) + strlen (rettype) + 3);
2094 sprintf (buf, "%s:%c%s", name,
2095 globalp ? 'F' : 'f',
2096 rettype);
2097
2098 /* We don't know the value now, so we set it in start_block. */
2099 info->fun_offset = info->symbols_size;
2100
2101 if (! stab_write_symbol (info, N_FUN, 0, 0, buf))
2102 return FALSE;
2103
2104 free (buf);
2105
2106 return TRUE;
2107 }
2108
2109 /* Output a function parameter. */
2110
2111 static bfd_boolean
stab_function_parameter(void * p,const char * name,enum debug_parm_kind kind,bfd_vma val)2112 stab_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val)
2113 {
2114 struct stab_write_handle *info = (struct stab_write_handle *) p;
2115 char *s, *buf;
2116 int stab_type;
2117 char kindc;
2118
2119 s = stab_pop_type (info);
2120
2121 switch (kind)
2122 {
2123 default:
2124 abort ();
2125
2126 case DEBUG_PARM_STACK:
2127 stab_type = N_PSYM;
2128 kindc = 'p';
2129 break;
2130
2131 case DEBUG_PARM_REG:
2132 stab_type = N_RSYM;
2133 kindc = 'P';
2134 break;
2135
2136 case DEBUG_PARM_REFERENCE:
2137 stab_type = N_PSYM;
2138 kindc = 'v';
2139 break;
2140
2141 case DEBUG_PARM_REF_REG:
2142 stab_type = N_RSYM;
2143 kindc = 'a';
2144 break;
2145 }
2146
2147 buf = (char *) xmalloc (strlen (name) + strlen (s) + 3);
2148 sprintf (buf, "%s:%c%s", name, kindc, s);
2149 free (s);
2150
2151 if (! stab_write_symbol (info, stab_type, 0, val, buf))
2152 return FALSE;
2153
2154 free (buf);
2155
2156 return TRUE;
2157 }
2158
2159 /* Start a block. */
2160
2161 static bfd_boolean
stab_start_block(void * p,bfd_vma addr)2162 stab_start_block (void *p, bfd_vma addr)
2163 {
2164 struct stab_write_handle *info = (struct stab_write_handle *) p;
2165
2166 /* Fill in any slots which have been waiting for the first known
2167 text address. */
2168
2169 if (info->so_offset != -1)
2170 {
2171 bfd_put_32 (info->abfd, addr, info->symbols + info->so_offset + 8);
2172 info->so_offset = -1;
2173 }
2174
2175 if (info->fun_offset != -1)
2176 {
2177 bfd_put_32 (info->abfd, addr, info->symbols + info->fun_offset + 8);
2178 info->fun_offset = -1;
2179 }
2180
2181 ++info->nesting;
2182
2183 /* We will be called with a top level block surrounding the
2184 function, but stabs information does not output that block, so we
2185 ignore it. */
2186
2187 if (info->nesting == 1)
2188 {
2189 info->fnaddr = addr;
2190 return TRUE;
2191 }
2192
2193 /* We have to output the LBRAC symbol after any variables which are
2194 declared inside the block. We postpone the LBRAC until the next
2195 start_block or end_block. */
2196
2197 /* If we have postponed an LBRAC, output it now. */
2198 if (info->pending_lbrac != (bfd_vma) -1)
2199 {
2200 if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
2201 (const char *) NULL))
2202 return FALSE;
2203 }
2204
2205 /* Remember the address and output it later. */
2206
2207 info->pending_lbrac = addr - info->fnaddr;
2208
2209 return TRUE;
2210 }
2211
2212 /* End a block. */
2213
2214 static bfd_boolean
stab_end_block(void * p,bfd_vma addr)2215 stab_end_block (void *p, bfd_vma addr)
2216 {
2217 struct stab_write_handle *info = (struct stab_write_handle *) p;
2218
2219 if (addr > info->last_text_address)
2220 info->last_text_address = addr;
2221
2222 /* If we have postponed an LBRAC, output it now. */
2223 if (info->pending_lbrac != (bfd_vma) -1)
2224 {
2225 if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
2226 (const char *) NULL))
2227 return FALSE;
2228 info->pending_lbrac = (bfd_vma) -1;
2229 }
2230
2231 assert (info->nesting > 0);
2232
2233 --info->nesting;
2234
2235 /* We ignore the outermost block. */
2236 if (info->nesting == 0)
2237 return TRUE;
2238
2239 return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr,
2240 (const char *) NULL);
2241 }
2242
2243 /* End a function. */
2244
2245 static bfd_boolean
stab_end_function(void * p ATTRIBUTE_UNUSED)2246 stab_end_function (void *p ATTRIBUTE_UNUSED)
2247 {
2248 return TRUE;
2249 }
2250
2251 /* Output a line number. */
2252
2253 static bfd_boolean
stab_lineno(void * p,const char * file,unsigned long lineno,bfd_vma addr)2254 stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr)
2255 {
2256 struct stab_write_handle *info = (struct stab_write_handle *) p;
2257
2258 assert (info->lineno_filename != NULL);
2259
2260 if (addr > info->last_text_address)
2261 info->last_text_address = addr;
2262
2263 if (strcmp (file, info->lineno_filename) != 0)
2264 {
2265 if (! stab_write_symbol (info, N_SOL, 0, addr, file))
2266 return FALSE;
2267 info->lineno_filename = file;
2268 }
2269
2270 return stab_write_symbol (info, N_SLINE, lineno, addr - info->fnaddr,
2271 (const char *) NULL);
2272 }
2273