Subversion Repositories tendra.SVN

Rev

Rev 5 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 7u83 1 
/*
6 7u83 2 
 * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.
3 
 * All rights reserved.
4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions are met:
7 
 *
8 
 * 1. Redistributions of source code must retain the above copyright notice,
9 
 *    this list of conditions and the following disclaimer.
10 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 
 *    this list of conditions and the following disclaimer in the documentation
12 
 *    and/or other materials provided with the distribution.
13 
 * 3. Neither the name of The TenDRA Project nor the names of its contributors
14 
 *    may be used to endorse or promote products derived from this software
15 
 *    without specific, prior written permission.
16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
18 
 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
19 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
21 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 
 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
27 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 
 *
29 
 * $Id$
30 
 */
31 
/*
2 7u83 32 
    		 Crown Copyright (c) 1997
33 
 
34 
    This TenDRA(r) Computer Program is subject to Copyright
35 
    owned by the United Kingdom Secretary of State for Defence
36 
    acting through the Defence Evaluation and Research Agency
37 
    (DERA).  It is made available to Recipients with a
38 
    royalty-free licence for its use, reproduction, transfer
39 
    to other parties and amendment for any purpose not excluding
40 
    product development provided that any such use et cetera
41 
    shall be deemed to be acceptance of the following conditions:-
42 
 
43 
        (1) Its Recipients shall ensure that this Notice is
44 
        reproduced upon any copies or amended versions of it;
45 
 
46 
        (2) Any amended version of it shall be clearly marked to
47 
        show both the nature of and the organisation responsible
48 
        for the relevant amendment or amendments;
49 
 
50 
        (3) Its onward transfer from a recipient to another
51 
        party shall be deemed to be that party's acceptance of
52 
        these conditions;
53 
 
54 
        (4) DERA gives no warranty or assurance as to its
55 
        quality or suitability for any purpose and DERA accepts
56 
        no liability whatsoever in relation to any use to which
57 
        it may be put.
58 
*/
59 
 
60 
 
61 
/**********************************************************************
62 
$Author: pwe $
63 
$Date: 1998/03/11 11:03:35 $
64 
$Revision: 1.3 $
65 
$Log: dw2_abbrev.c,v $
66 
 * Revision 1.3  1998/03/11  11:03:35  pwe
67 
 * DWARF optimisation info
68 
 *
69 
 * Revision 1.2  1998/02/18  11:22:16  pwe
70 
 * test corrections
71 
 *
72 
 * Revision 1.1.1.1  1998/01/17  15:55:48  release
73 
 * First version to be checked into rolling release.
74 
 *
75 
 * Revision 1.7  1998/01/09  09:31:44  pwe
76 
 * prep restructure
77 
 *
78 
 * Revision 1.6  1997/12/08  16:37:17  pwe
79 
 * abbrev key & directory names
80 
 *
81 
 * Revision 1.5  1997/12/05  10:24:06  pwe
82 
 * name change
83 
 *
84 
 * Revision 1.4  1997/12/04  19:41:58  pwe
85 
 * ANDF-DE V1.9
86 
 *
87 
 * Revision 1.3  1997/11/06  09:22:35  pwe
88 
 * ANDF-DE V1.8
89 
 *
90 
 * Revision 1.2  1997/10/23  09:28:02  pwe
91 
 * ANDF-DE v1.7, extra diags
92 
 *
93 
 * Revision 1.1  1997/10/10  18:19:00  pwe
94 
 * prep ANDF-DE revision
95 
 *
96 
 * Revision 1.6  1997/08/23  13:36:26  pwe
97 
 * initial ANDF-DE
98 
 *
99 
 * Revision 1.5  1997/05/02  11:00:28  pwe
100 
 * stmt_list is ref_addr
101 
 *
102 
 * Revision 1.4  1997/04/17  11:50:07  pwe
103 
 * Sparc and 80x86 support
104 
 *
105 
 * Revision 1.3  1997/04/01  17:19:29  pwe
106 
 * diagnose pl_tests and locate -> platform specific
107 
 *
108 
 * Revision 1.2  1997/03/24  11:10:12  pwe
109 
 * struct bitfields
110 
 *
111 
 * Revision 1.1  1997/03/20  16:08:52  pwe
112 
 * first version
113 
 *
114 
**********************************************************************/
115 
 
116 
#include "config.h"
117 
#include "dw2_config.h"
118 
#include "dw2_basic.h"
119 
#include "dw2_abbrev.h"
120 
#include "dw2_abbrev_vn.h"
121 
#include "dw2_codes.h"
122 
#include "dw2_entries.h"
123 
#include "readglob.h"
124 
 
125 
 
6 7u83 126 
static void
127 
sep(void)
2 7u83 128 
{
6 7u83 129 
	outs(", ");
130 
	return;
2 7u83 131 
}
132 
 
6 7u83 133 
 
134 
static void
135 
set_abbrev_tag(abbrev_entry *en, int c, int tag_code, int has_children)
2 7u83 136 
{
6 7u83 137 
	if (!en->index && !c) {
138 
		good_trans = 1;
139 
		IGNORE printf("!!!	abbreviation index unset: %s\n",
140 
			      en->aname);
141 
	}
142 
	out8();
143 
	uleb128((unsigned long)(en->index + c));
144 
	sep();
145 
	uleb128((unsigned long)tag_code);
146 
	sep();
147 
	outn(has_children ? (long)DW_CHILDREN_yes : (long)DW_CHILDREN_no);
148 
	outnl_comment_i(en->aname, (long)c);
149 
	return;
2 7u83 150 
}
151 
 
6 7u83 152 
 
153 
static void
154 
set_decl_attributes(void)
2 7u83 155 
{
6 7u83 156 
	set_attribute(DW_AT_decl_file, DW_FORM_udata);
157 
	set_attribute(DW_AT_decl_line, DW_FORM_udata);
158 
	set_attribute(DW_AT_decl_column, DW_FORM_udata);
2 7u83 159 
}
160 
 
6 7u83 161 
 
162 
static void
163 
obj_abbrev(abbrev_entry *en, int tag_code)
2 7u83 164 
{
6 7u83 165 
	int c = 0;
166 
	do {
167 
		long attr = (en->attr)[c];
168 
		set_abbrev_tag(en, c, tag_code, 0);
169 
		if (attr & H_AO) {
170 
			set_attribute(DW_AT_abstract_origin, DW_FORM_ref_addr);
171 
		}
172 
		if (attr & H_SP) {
173 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
174 
		}
175 
		if (attr & H_DC) {
176 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
177 
		}
178 
		if (attr & H_NM) {
179 
			set_attribute(DW_AT_name, DW_FORM_string);
180 
		}
181 
		if (attr & H_XY) {
182 
			set_decl_attributes();
183 
		}
184 
		if (attr & H_EX) {
185 
			set_attribute(DW_AT_external, DW_FORM_flag);
186 
		}
187 
		if (attr & H_AT) {
188 
			set_attribute(DW_AT_artificial, DW_FORM_flag);
189 
		}
190 
		if (attr & H_AC) {
191 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
192 
		}
193 
		if (attr & H_TP) {
194 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
195 
		}
196 
		if (attr & H_VP) {
197 
			set_attribute(DW_AT_variable_parameter, DW_FORM_flag);
198 
		}
2 7u83 199 
#ifdef H_DX
6 7u83 200 
		if (attr & H_DX) {
201 
			set_attribute(DW_AT_DD_computed_default, DW_FORM_flag);
202 
		}
2 7u83 203 
#endif
6 7u83 204 
		if (attr & H_DF) {
205 
			set_attribute(DW_AT_default_value, DW_FORM_indirect);
206 
		}
207 
		if (attr & H_SS) {
208 
			set_attribute(DW_AT_start_scope, DW_FORM_data2);
209 
		}
210 
		if (attr & H_CV) {
211 
			set_attribute(DW_AT_const_value, DW_FORM_indirect);
212 
		}
213 
		if (attr & H_LC) {
214 
			set_attribute(DW_AT_location, DW_FORM_block1);
215 
		}
216 
		if (attr & H_LL) {
217 
			set_attribute(DW_AT_location, DW_FORM_ref_addr);
218 
		}
219 
		if (attr & H_LE) {
220 
			set_attribute(DW_AT_DD_ext_location, DW_FORM_ref_addr);
221 
		}
222 
		if (attr & H_RP) {
223 
			set_attribute(DW_AT_DD_repn, DW_FORM_indirect);
224 
		}
225 
		set_attribute(0, 0);
226 
		c++;
227 
	} while ((en->attr)[c]);
228 
	return;
2 7u83 229 
}
230 
 
6 7u83 231 
 
232 
static void
233 
module_abbrev(abbrev_entry *en, int tag_code)
2 7u83 234 
{
6 7u83 235 
	int c = 0;
236 
	do {
237 
		long attr = (en->attr)[c];
238 
		set_abbrev_tag(en, c, tag_code, 1);
239 
		if (attr & H_AO) {
240 
			set_attribute(DW_AT_abstract_origin, DW_FORM_ref_addr);
241 
		}
242 
		if (attr & H_SP) {
243 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
244 
		}
245 
		if (attr & H_DC) {
246 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
247 
		}
248 
		if (attr & H_NM) {
249 
			set_attribute(DW_AT_name, DW_FORM_string);
250 
		}
251 
		if (attr & H_XY) {
252 
			set_decl_attributes();
253 
		}
254 
		if (attr & H_AT) {
255 
			set_attribute(DW_AT_artificial, DW_FORM_flag);
256 
		}
257 
		if (attr & H_AC) {
258 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
259 
		}
260 
		if (attr & H_PC) {
261 
			set_attribute(DW_AT_low_pc, DW_FORM_addr);
262 
			set_attribute(DW_AT_high_pc, DW_FORM_addr);
263 
		}
264 
		if (attr & H_EXTN) {
265 
			set_attribute(DW_AT_DD_indirect_attributes,
266 
				      DW_FORM_block2);
267 
		}
268 
		set_attribute(0, 0);
269 
		c++;
270 
	} while ((en->attr)[c]);
271 
	return;
2 7u83 272 
}
273 
 
6 7u83 274 
 
275 
static void
276 
struct_abbrev(abbrev_entry *en, int tag_code)
2 7u83 277 
{
6 7u83 278 
	int c = 0;
279 
	do {
280 
		long attr = (en->attr)[c];
281 
		set_abbrev_tag(en, c, tag_code, 1);
282 
		if (attr & H_SP) {
283 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
284 
		}
285 
		if (attr & H_DC) {
286 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
287 
		}
288 
		if (attr & H_NM) {
289 
			set_attribute(DW_AT_name, DW_FORM_string);
290 
		}
291 
		if (attr & H_XY) {
292 
			set_decl_attributes();
293 
		}
294 
		if (attr & H_SZ) {
295 
			set_attribute(DW_AT_byte_size, DW_FORM_udata);
296 
		}
297 
		if (attr & H_NW) {
298 
			set_attribute(DW_AT_DD_newtype, DW_FORM_flag);
299 
		}
300 
		if (attr & H_EXTN) {
301 
			set_attribute(DW_AT_DD_indirect_attributes,
302 
				      DW_FORM_block2);
303 
		}
304 
		set_attribute(0, 0);
305 
		c++;
306 
	} while ((en->attr)[c]);
307 
	return;
2 7u83 308 
}
309 
 
310 
 
6 7u83 311 
void
312 
do_abbreviations(void)
2 7u83 313 
{
6 7u83 314 
	int c;
315 
	enter_section("debug_abbrev");
316 
	out_ext_label(abbrev_name);
2 7u83 317 
 
6 7u83 318 
	set_abbrev_tag(&dwe_comp_unit, 0, DW_TAG_compile_unit, 1);
319 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
320 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
321 
	set_attribute(DW_AT_name, DW_FORM_string);
322 
	set_attribute(DW_AT_language, DW_FORM_udata);
323 
	set_attribute(DW_AT_stmt_list, DW_FORM_ref_addr);
324 
	set_attribute(DW_AT_comp_dir, DW_FORM_string);
325 
	set_attribute(DW_AT_producer, DW_FORM_string);
326 
	set_attribute(DW_AT_identifier_case, DW_FORM_data1);
327 
	set_attribute(0, 0);
2 7u83 328 
 
6 7u83 329 
	set_abbrev_tag(&dwe_cmac_unit, 0, DW_TAG_compile_unit, 1);
330 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
331 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
332 
	set_attribute(DW_AT_name, DW_FORM_string);
333 
	set_attribute(DW_AT_language, DW_FORM_udata);
334 
	set_attribute(DW_AT_stmt_list, DW_FORM_ref_addr);
335 
	set_attribute(DW_AT_macro_info, DW_FORM_ref_addr);
336 
	set_attribute(DW_AT_comp_dir, DW_FORM_string);
337 
	set_attribute(DW_AT_producer, DW_FORM_string);
338 
	set_attribute(DW_AT_identifier_case, DW_FORM_data1);
339 
	set_attribute(0, 0);
2 7u83 340 
 
6 7u83 341 
	module_abbrev(&dwe_module, DW_TAG_module);
2 7u83 342 
 
6 7u83 343 
	module_abbrev(&dwe_namespace, DW_TAG_DD_namespace);
2 7u83 344 
 
6 7u83 345 
	set_abbrev_tag(&dwe_subunit, 0, DW_TAG_DD_subunit, 1);
346 
	set_attribute(DW_AT_DD_parent, DW_FORM_ref_addr);
347 
	set_attribute(DW_AT_artificial, DW_FORM_flag);
348 
	set_attribute(0, 0);
2 7u83 349 
 
6 7u83 350 
	set_abbrev_tag(&dwe_childunit, 0, DW_TAG_DD_child_unit, 1);
351 
	set_attribute(DW_AT_DD_parent, DW_FORM_ref_addr);
352 
	set_attribute(0, 0);
2 7u83 353 
 
6 7u83 354 
	set_abbrev_tag(&dwe_child_acc, 0, DW_TAG_DD_child_unit, 1);
355 
	set_attribute(DW_AT_DD_parent, DW_FORM_ref_addr);
356 
	set_attribute(DW_AT_accessibility, DW_FORM_data1);
357 
	set_attribute(0, 0);
2 7u83 358 
 
6 7u83 359 
	c = 0;
360 
	do {
361 
		long attr = (dwe_import.attr)[c];
362 
		set_abbrev_tag(&dwe_import, c, DW_TAG_imported_declaration, 0);
363 
		if (attr & H_NM) {
364 
			set_attribute(DW_AT_name, DW_FORM_string);
365 
		}
366 
		if (attr & H_XY) {
367 
			set_decl_attributes();
368 
		}
369 
		if (attr & H_AC) {
370 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
371 
		}
372 
		set_attribute(DW_AT_import, DW_FORM_ref_addr);
373 
		set_attribute(DW_AT_DD_import_kind, DW_FORM_udata);
374 
		if (attr & H_SS) {
375 
			set_attribute(DW_AT_start_scope, DW_FORM_data2);
376 
		}
377 
		set_attribute(0, 0);
378 
		c++;
379 
	} while ((dwe_import.attr)[c]);
2 7u83 380 
 
6 7u83 381 
	c = 0;
382 
	do {
383 
		long attr = (dwe_import_p.attr)[c];
384 
		set_abbrev_tag(&dwe_import_p, c, DW_TAG_imported_declaration, 1);
385 
		if (attr & H_NM) {
386 
			set_attribute(DW_AT_name, DW_FORM_string);
387 
		}
388 
		if (attr & H_XY) {
389 
			set_decl_attributes();
390 
		}
391 
		if (attr & H_AC) {
392 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
393 
		}
394 
		set_attribute(DW_AT_import, DW_FORM_ref_addr);
395 
		set_attribute(DW_AT_DD_import_kind, DW_FORM_udata);
396 
		if (attr & H_SS) {
397 
			set_attribute(DW_AT_start_scope, DW_FORM_data2);
398 
		}
399 
		set_attribute(0, 0);
400 
		c++;
401 
	} while ((dwe_import_p.attr)[c]);
2 7u83 402 
 
6 7u83 403 
	c = 0;
404 
	do {
405 
		long attr = (dwe_proc.attr)[c];
406 
		set_abbrev_tag(&dwe_proc, c, DW_TAG_subprogram, 1);
407 
		if (attr & H_AO) {
408 
			set_attribute(DW_AT_abstract_origin, DW_FORM_ref_addr);
409 
		}
410 
		if (attr & H_SP) {
411 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
412 
		}
413 
		if (attr & H_DC) {
414 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
415 
		}
416 
		if (attr & H_NM) {
417 
			set_attribute(DW_AT_name, DW_FORM_string);
418 
		}
419 
		if (attr & H_XY) {
420 
			set_decl_attributes();
421 
		}
422 
		if (attr & H_EX) {
423 
			set_attribute(DW_AT_external, DW_FORM_flag);
424 
		}
425 
		if (attr & H_AT) {
426 
			set_attribute(DW_AT_artificial, DW_FORM_flag);
427 
		}
428 
		if (attr & H_AC) {
429 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
430 
		}
431 
		if (attr & H_CC) {
432 
			set_attribute(DW_AT_calling_convention, DW_FORM_data1);
433 
		}
434 
		if (attr & H_TP) {
435 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
436 
		}
437 
		if (attr & H_PT) {
438 
			set_attribute(DW_AT_prototyped, DW_FORM_flag);
439 
		}
440 
		if (attr & H_IL) {
441 
			set_attribute(DW_AT_inline, DW_FORM_data1);
442 
		}
443 
		if (attr & H_VT) {
444 
			set_attribute(DW_AT_virtuality, DW_FORM_data1);
445 
		}
446 
		if (attr & H_VL) {
447 
			set_attribute(DW_AT_vtable_elem_location,
448 
				      DW_FORM_block1);
449 
		}
450 
		if (attr & H_SS) {
451 
			set_attribute(DW_AT_start_scope, DW_FORM_data2);
452 
		}
453 
		if (attr & H_PC) {
454 
			set_attribute(DW_AT_low_pc, DW_FORM_addr);
455 
			set_attribute(DW_AT_high_pc, DW_FORM_addr);
456 
			set_attribute(DW_AT_return_addr, DW_FORM_block1);
457 
			set_attribute(DW_AT_frame_base, DW_FORM_block1);
458 
		}
459 
		if (attr & H_SL) {
460 
			set_attribute(DW_AT_static_link, DW_FORM_block1);
461 
		}
462 
		if (attr & H_EXTN) {
463 
			set_attribute(DW_AT_DD_indirect_attributes,
464 
				      DW_FORM_block2);
465 
		}
466 
		if (attr & H_EL) {
467 
			set_attribute(DW_AT_DD_elaboration, DW_FORM_ref_addr);
468 
		}
469 
		if (attr & H_GN) {
470 
			set_attribute(DW_AT_DD_generic_name, DW_FORM_string);
471 
		}
472 
		if (attr & H_RP) {
473 
			set_attribute(DW_AT_DD_repn, DW_FORM_indirect);
474 
		}
475 
		if (attr & H_LN) {
476 
			set_attribute(DW_AT_language, DW_FORM_udata);
477 
		}
478 
		set_attribute(0, 0);
479 
		c++;
480 
	} while ((dwe_proc.attr)[c]);
2 7u83 481 
 
6 7u83 482 
	set_abbrev_tag(&dwe_entrypt, 0, DW_TAG_entry_point, 0);
483 
	set_attribute(0, 0);
2 7u83 484 
 
6 7u83 485 
	obj_abbrev(&dwe_param, DW_TAG_formal_parameter);
2 7u83 486 
 
6 7u83 487 
	set_abbrev_tag(&dwe_formal, 0, DW_TAG_formal_parameter, 0);
488 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
489 
	set_attribute(0, 0);
2 7u83 490 
 
6 7u83 491 
	set_abbrev_tag(&dwe_opt_par, 0, DW_TAG_unspecified_parameters, 0);
492 
	set_attribute(0, 0);
2 7u83 493 
 
6 7u83 494 
	set_abbrev_tag(&dwe_thrown_t, 0, DW_TAG_thrown_type, 0);
495 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
496 
	set_attribute(0, 0);
2 7u83 497 
 
6 7u83 498 
	set_abbrev_tag(&dwe_inl_call, 0, DW_TAG_inlined_subroutine, 1);
499 
	set_attribute(DW_AT_abstract_origin, DW_FORM_ref_addr);
500 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
501 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
502 
	set_attribute(0, 0);
2 7u83 503 
 
6 7u83 504 
	set_abbrev_tag(&dwe_inl_opnd, 0, DW_TAG_inlined_subroutine, 1);
505 
	set_attribute(DW_AT_abstract_origin, DW_FORM_ref_addr);
506 
	set_attribute(0, 0);
2 7u83 507 
 
6 7u83 508 
	c = 0;
509 
	do {
510 
		long attr = (dwe_scope.attr)[c];
511 
		set_abbrev_tag(&dwe_scope, c, DW_TAG_lexical_block, 1);
512 
		if (attr & H_NM) {
513 
			set_attribute(DW_AT_name, DW_FORM_string);
514 
		}
515 
		if (attr & H_XY) {
516 
			set_decl_attributes();
517 
		}
518 
		if (attr & H_PC) {
519 
			set_attribute(DW_AT_low_pc, DW_FORM_addr);
520 
			set_attribute(DW_AT_high_pc, DW_FORM_addr);
521 
		}
522 
		if (attr & H_BG) {
523 
			set_attribute(DW_AT_DD_begin, DW_FORM_addr);
524 
		}
525 
		set_attribute(0, 0);
526 
		c++;
527 
	} while ((dwe_scope.attr)[c]);
2 7u83 528 
 
6 7u83 529 
	set_abbrev_tag(&dwe_fragment, 0, DW_TAG_DD_lexical_fragment, 1);
530 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
531 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
532 
	set_attribute(0, 0);
2 7u83 533 
 
6 7u83 534 
	set_abbrev_tag(&dwe_label, 0, DW_TAG_label, 0);
535 
	set_attribute(DW_AT_name, DW_FORM_string);
536 
	set_decl_attributes();
537 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
538 
	set_attribute(0, 0);
2 7u83 539 
 
6 7u83 540 
	set_abbrev_tag(&dwe_with, 0, DW_TAG_with_stmt, 1);
541 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
542 
	set_attribute(DW_AT_location, DW_FORM_block1);
543 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
544 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
545 
	set_attribute(0, 0);
2 7u83 546 
 
6 7u83 547 
	set_abbrev_tag(&dwe_try, 0, DW_TAG_try_block, 1);
548 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
549 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
550 
	set_attribute(0, 0);
2 7u83 551 
 
6 7u83 552 
	set_abbrev_tag(&dwe_catch, 0, DW_TAG_catch_block, 1);
553 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
554 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
555 
	set_attribute(0, 0);
2 7u83 556 
 
6 7u83 557 
	obj_abbrev(&dwe_variable, DW_TAG_variable);
558 
	obj_abbrev(&dwe_constant, DW_TAG_constant);
2 7u83 559 
 
6 7u83 560 
	set_abbrev_tag(&dwe_tmpl_type, 0, DW_TAG_template_type_param, 0);
561 
	set_attribute(DW_AT_name, DW_FORM_string);
562 
	set_decl_attributes();
563 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
564 
	set_attribute(0, 0);
2 7u83 565 
 
6 7u83 566 
	set_abbrev_tag(&dwe_tmpl_val, 0, DW_TAG_template_value_param, 0);
567 
	set_attribute(DW_AT_name, DW_FORM_string);
568 
	set_decl_attributes();
569 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
570 
	set_attribute(DW_AT_const_value, DW_FORM_indirect);
571 
	set_attribute(0, 0);
2 7u83 572 
 
6 7u83 573 
	set_abbrev_tag(&dwe_tmpl_proc, 0, DW_TAG_DD_template_proc_param, 0);
574 
	set_attribute(DW_AT_name, DW_FORM_string);
575 
	set_decl_attributes();
576 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
577 
	set_attribute(0, 0);
2 7u83 578 
 
6 7u83 579 
	set_abbrev_tag(&dwe_tmpl_mod, 0, DW_TAG_DD_template_module_param, 0);
580 
	set_attribute(DW_AT_name, DW_FORM_string);
581 
	set_decl_attributes();
582 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
583 
	set_attribute(0, 0);
2 7u83 584 
 
6 7u83 585 
	c = 0;
586 
	do {
587 
		long attr = (dwe_typedef.attr)[c];
588 
		set_abbrev_tag(&dwe_typedef, c, DW_TAG_typedef, 0);
589 
		if (attr & H_AO) {
590 
			set_attribute(DW_AT_abstract_origin, DW_FORM_ref_addr);
591 
		}
592 
		if (attr & H_SP) {
593 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
594 
		}
595 
		if (attr & H_DC) {
596 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
597 
		}
598 
		if (attr & H_NM) {
599 
			set_attribute(DW_AT_name, DW_FORM_string);
600 
		}
601 
		if (attr & H_XY) {
602 
			set_decl_attributes();
603 
		}
604 
		if (attr & H_AT) {
605 
			set_attribute(DW_AT_artificial, DW_FORM_flag);
606 
		}
607 
		if (attr & H_AC) {
608 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
609 
		}
610 
		if (attr & H_TP) {
611 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
612 
		}
613 
		if (attr & H_NW) {
614 
			set_attribute(DW_AT_DD_newtype, DW_FORM_flag);
615 
		}
616 
		if (attr & H_AD) {
617 
			set_attribute(DW_AT_DD_ada_derived, DW_FORM_flag);
618 
		}
619 
		set_attribute(0, 0);
620 
		c++;
621 
	} while ((dwe_typedef.attr)[c]);
2 7u83 622 
 
6 7u83 623 
	c = 0;
624 
	do {
625 
		long attr = (dwe_typecon.attr)[c];
626 
		set_abbrev_tag(&dwe_typecon, c, DW_TAG_typedef, 1);
627 
		if (attr & H_SP) {
628 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
629 
		}
630 
		if (attr & H_DC) {
631 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
632 
		}
633 
		if (attr & H_NM) {
634 
			set_attribute(DW_AT_name, DW_FORM_string);
635 
		}
636 
		if (attr & H_XY) {
637 
			set_decl_attributes();
638 
		}
639 
		if (attr & H_AT) {
640 
			set_attribute(DW_AT_artificial, DW_FORM_flag);
641 
		}
642 
		if (attr & H_AC) {
643 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
644 
		}
645 
		if (attr & H_TP) {
646 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
647 
		}
648 
		if (attr & H_NW) {
649 
			set_attribute(DW_AT_DD_newtype, DW_FORM_flag);
650 
		}
651 
		if (attr & H_AD) {
652 
			set_attribute(DW_AT_DD_ada_derived, DW_FORM_flag);
653 
		}
654 
		set_attribute(0, 0);
655 
		c++;
656 
	} while ((dwe_typecon.attr)[c]);
2 7u83 657 
 
6 7u83 658 
	c = 0;
659 
	do {
660 
		long attr = (dwe_cnstraint.attr)[c];
661 
		set_abbrev_tag(&dwe_cnstraint, c, DW_TAG_DD_constraint, 0);
662 
		if (attr & H_RM) {
663 
			set_attribute(DW_AT_DD_constraint_ref,
664 
				      DW_FORM_ref_addr);
665 
		}
666 
		if (attr & H_CV) {
667 
			set_attribute(DW_AT_const_value, DW_FORM_indirect);
668 
		}
669 
		if (attr & H_TP) {
670 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
671 
		}
672 
		set_attribute(0, 0);
673 
		c++;
674 
	} while ((dwe_cnstraint.attr)[c]);
2 7u83 675 
 
6 7u83 676 
	set_abbrev_tag(&dwe_base_type, 0, DW_TAG_base_type, 0);
677 
	set_attribute(DW_AT_name, DW_FORM_string);
678 
	set_attribute(DW_AT_encoding, DW_FORM_data1);
679 
	set_attribute(DW_AT_byte_size, DW_FORM_udata);
680 
	set_attribute(0, 0);
2 7u83 681 
 
6 7u83 682 
	set_abbrev_tag(&dwe_cnst_type, 0, DW_TAG_const_type, 0);
683 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
684 
	set_attribute(0, 0);
2 7u83 685 
 
6 7u83 686 
	set_abbrev_tag(&dwe_vol_type, 0, DW_TAG_volatile_type, 0);
687 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
688 
	set_attribute(0, 0);
2 7u83 689 
 
6 7u83 690 
	set_abbrev_tag(&dwe_clwd_type, 0, DW_TAG_DD_class_wide_type, 0);
691 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
692 
	set_attribute(0, 0);
2 7u83 693 
 
6 7u83 694 
	set_abbrev_tag(&dwe_als_type, 0, DW_TAG_DD_aliased_type, 0);
695 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
696 
	set_attribute(0, 0);
2 7u83 697 
 
6 7u83 698 
	set_abbrev_tag(&dwe_lim_type, 0, DW_TAG_DD_limited_type, 0);
699 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
700 
	set_attribute(0, 0);
2 7u83 701 
 
6 7u83 702 
	set_abbrev_tag(&dwe_ptr_type, 0, DW_TAG_pointer_type, 0);
703 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
704 
	set_attribute(0, 0);
2 7u83 705 
 
6 7u83 706 
	set_abbrev_tag(&dwe_hpptr_t, 0, DW_TAG_pointer_type, 0);
707 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
708 
	set_attribute(DW_AT_DD_heap_only_pointer, DW_FORM_flag);
709 
	set_attribute(0, 0);
2 7u83 710 
 
6 7u83 711 
	set_abbrev_tag(&dwe_ref_type, 0, DW_TAG_reference_type, 0);
712 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
713 
	set_attribute(0, 0);
2 7u83 714 
 
6 7u83 715 
	set_abbrev_tag(&dwe_pack_type, 0, DW_TAG_packed_type, 0);
716 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
717 
	set_attribute(0, 0);
2 7u83 718 
 
6 7u83 719 
	set_abbrev_tag(&dwe_arr_type, 0, DW_TAG_array_type, 1);
720 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
721 
	set_attribute(DW_AT_stride_size, DW_FORM_indirect);
722 
	set_attribute(DW_AT_ordering, DW_FORM_data1);
723 
	set_attribute(DW_AT_byte_size, DW_FORM_udata);
724 
	set_attribute(0, 0);
2 7u83 725 
 
6 7u83 726 
	set_abbrev_tag(&dwe_arr_dyn, 0, DW_TAG_array_type, 1);
727 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
728 
	set_attribute(DW_AT_stride_size, DW_FORM_indirect);
729 
	set_attribute(DW_AT_ordering, DW_FORM_data1);
730 
	set_attribute(0, 0);
2 7u83 731 
 
6 7u83 732 
	c = 0;
733 
	do {
734 
		long attr = (dwe_subr_type.attr)[c];
735 
		set_abbrev_tag(&dwe_subr_type, c, DW_TAG_subrange_type, 0);
736 
		if (attr & H_TP) {
737 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
738 
		}
739 
		if (attr & H_SZ) {
740 
			set_attribute(DW_AT_byte_size, DW_FORM_udata);
741 
		}
742 
		if (attr & H_LB) {
743 
			set_attribute(DW_AT_lower_bound, DW_FORM_indirect);
744 
		}
745 
		if (attr & H_UB) {
746 
			set_attribute(DW_AT_upper_bound, DW_FORM_indirect);
747 
		}
748 
		if (attr & H_CN) {
749 
			set_attribute(DW_AT_count, DW_FORM_indirect);
750 
		}
751 
		set_attribute(0, 0);
752 
		c++;
753 
	} while ((dwe_subr_type.attr)[c]);
2 7u83 754 
 
6 7u83 755 
	c = 0;
756 
	do {
757 
		long attr = (dwe_enum_type.attr)[c];
758 
		set_abbrev_tag(&dwe_enum_type, c, DW_TAG_enumeration_type, 1);
759 
		if (attr & H_SP) {
760 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
761 
		}
762 
		if (attr & H_DC) {
763 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
764 
		}
765 
		if (attr & H_NM) {
766 
			set_attribute(DW_AT_name, DW_FORM_string);
767 
		}
768 
		if (attr & H_XY) {
769 
			set_decl_attributes();
770 
		}
771 
		if (attr & H_SZ) {
772 
			set_attribute(DW_AT_byte_size, DW_FORM_udata);
773 
		}
774 
		if (attr & H_NW) {
775 
			set_attribute(DW_AT_DD_newtype, DW_FORM_flag);
776 
		}
777 
		set_attribute(0, 0);
778 
		c++;
779 
	} while ((dwe_enum_type.attr)[c]);
2 7u83 780 
 
6 7u83 781 
	set_abbrev_tag(&dwe_enum_tor, 0, DW_TAG_enumerator, 0);
782 
	set_attribute(DW_AT_name, DW_FORM_string);
783 
	set_attribute(DW_AT_const_value, DW_FORM_indirect);
784 
	set_attribute(0, 0);
2 7u83 785 
 
6 7u83 786 
	set_abbrev_tag(&dwe_enum_char, 0, DW_TAG_enumerator, 0);
787 
	set_attribute (DW_AT_name, DW_FORM_udata);	/* character constant */
788 
	set_attribute(DW_AT_const_value, DW_FORM_indirect);
789 
	set_attribute(0, 0);
2 7u83 790 
 
6 7u83 791 
	struct_abbrev(&dwe_struct_t, DW_TAG_structure_type);
2 7u83 792 
 
6 7u83 793 
	struct_abbrev(&dwe_union_t, DW_TAG_union_type);
2 7u83 794 
 
6 7u83 795 
	struct_abbrev(&dwe_class_t, DW_TAG_class_type);
2 7u83 796 
 
6 7u83 797 
	c = 0;
798 
	do {
799 
		long attr = (dwe_member.attr)[c];
800 
		set_abbrev_tag(&dwe_member, c, DW_TAG_member, 0);
801 
		if (attr & H_NM) {
802 
			set_attribute(DW_AT_name, DW_FORM_string);
803 
		}
804 
		if (attr & H_XY) {
805 
			set_decl_attributes();
806 
		}
807 
		if (attr & H_AC) {
808 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
809 
		}
810 
		if (attr & H_TP) {
811 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
812 
		}
813 
		if (attr & H_LC) {
814 
			set_attribute(DW_AT_data_member_location,
815 
				      DW_FORM_block1);
816 
		}
817 
		if (attr & H_BF) {
818 
			set_attribute(DW_AT_bit_offset, DW_FORM_data1);
819 
			set_attribute(DW_AT_bit_size, DW_FORM_data1);
820 
		}
821 
		if (attr & H_DS) {
822 
			set_attribute(DW_AT_DD_discriminant, DW_FORM_flag);
823 
		}
2 7u83 824 
#ifdef H_DX
6 7u83 825 
		if (attr & H_DX) {
826 
			set_attribute(DW_AT_DD_computed_default, DW_FORM_flag);
827 
		}
2 7u83 828 
#endif
6 7u83 829 
		if (attr & H_DF) {
830 
			set_attribute(DW_AT_default_value, DW_FORM_indirect);
831 
		}
832 
		set_attribute(0, 0);
833 
		c++;
834 
	} while ((dwe_member.attr)[c]);
2 7u83 835 
 
6 7u83 836 
	set_abbrev_tag(&dwe_varpart, 0, DW_TAG_variant_part, 1);
837 
	set_attribute(DW_AT_discr, DW_FORM_ref_addr);
838 
	set_attribute(0, 0);
2 7u83 839 
 
6 7u83 840 
	set_abbrev_tag(&dwe_varpart_t, 0, DW_TAG_variant_part, 1);
841 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
842 
	set_attribute(0, 0);
2 7u83 843 
 
6 7u83 844 
	set_abbrev_tag(&dwe_variant_0, 0, DW_TAG_variant, 1);
845 
	set_attribute(0, 0);
2 7u83 846 
 
6 7u83 847 
	set_abbrev_tag(&dwe_variant_1, 0, DW_TAG_variant, 1);
848 
	set_attribute(DW_AT_discr_value, DW_FORM_indirect);
849 
	set_attribute(0, 0);
2 7u83 850 
 
6 7u83 851 
	set_abbrev_tag(&dwe_variant_n, 0, DW_TAG_variant, 1);
852 
	set_attribute(DW_AT_discr_list, DW_FORM_block2);
853 
	set_attribute(0, 0);
2 7u83 854 
 
6 7u83 855 
	c = 0;
856 
	do {
857 
		long attr = (dwe_inheritce.attr)[c];
858 
		set_abbrev_tag(&dwe_inheritce, c, DW_TAG_inheritance, 0);
859 
		if (attr & H_XY) {
860 
			set_decl_attributes();
861 
		}
862 
		if (attr & H_TP) {
863 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
864 
		}
865 
		if (attr & H_LC) {
866 
			set_attribute(DW_AT_data_member_location,
867 
				      DW_FORM_block1);
868 
		}
869 
		if (attr & H_AC) {
870 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
871 
		}
872 
		if (attr & H_VT) {
873 
			set_attribute(DW_AT_virtuality, DW_FORM_data1);
874 
		}
875 
		set_attribute(0, 0);
876 
		c++;
877 
	} while ((dwe_inheritce.attr)[c]);
2 7u83 878 
 
6 7u83 879 
	set_abbrev_tag(&dwe_friend, 0, DW_TAG_friend, 0);
880 
	set_attribute(DW_AT_friend, DW_FORM_ref_addr);
881 
	set_attribute(0, 0);
2 7u83 882 
 
6 7u83 883 
	set_abbrev_tag(&dwe_ptrmem_t, 0, DW_TAG_ptr_to_member_type, 0);
884 
	set_attribute(DW_AT_containing_type, DW_FORM_ref_addr);
885 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
886 
	set_attribute(DW_AT_byte_size, DW_FORM_udata);
887 
	set_attribute(0, 0);
2 7u83 888 
 
6 7u83 889 
	c = 0;
890 
	do {
891 
		long attr = (dwe_ind_mem.attr)[c];
892 
		set_abbrev_tag(&dwe_ind_mem, c, DW_TAG_DD_indirect_member, 0);
893 
		if (attr & H_NM) {
894 
			set_attribute(DW_AT_name, DW_FORM_string);
895 
		}
896 
		if (attr & H_XY) {
897 
			set_decl_attributes();
898 
		}
899 
		if (attr & H_TP) {
900 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
901 
		}
902 
		if (attr & H_LC) {
903 
			set_attribute(DW_AT_data_member_location,
904 
				      DW_FORM_block1);
905 
		}
906 
		set_attribute(0, 0);
907 
		c++;
908 
	} while ((dwe_ind_mem.attr)[c]);
2 7u83 909 
 
6 7u83 910 
	set_abbrev_tag(&dwe_proc_type, 0, DW_TAG_subroutine_type, 1);
911 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
912 
	set_attribute(0, 0);
2 7u83 913 
 
6 7u83 914 
	set_abbrev_tag(&dwe_procv_t, 0, DW_TAG_subroutine_type, 1);
915 
	set_attribute(0, 0);
2 7u83 916 
 
6 7u83 917 
	set_abbrev_tag(&dwe_string_t, 0, DW_TAG_string_type, 0);
918 
	set_attribute(DW_AT_string_length, DW_FORM_block1);
919 
	set_attribute(DW_AT_byte_size, DW_FORM_udata);
920 
	set_attribute(0, 0);
2 7u83 921 
 
6 7u83 922 
	set_abbrev_tag(&dwe_stringc_t, 0, DW_TAG_string_type, 0);
923 
	set_attribute(DW_AT_byte_size, DW_FORM_udata);
924 
	set_attribute(0, 0);
2 7u83 925 
 
6 7u83 926 
	c = 0;
927 
	do {
928 
		long attr = (dwe_file_t.attr)[c];
929 
		set_abbrev_tag(&dwe_file_t, c, DW_TAG_file_type, 0);
930 
		if (attr & H_SP) {
931 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
932 
		}
933 
		if (attr & H_DC) {
934 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
935 
		}
936 
		if (attr & H_TP) {
937 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
938 
		}
939 
		if (attr & H_SZ) {
940 
			set_attribute(DW_AT_byte_size, DW_FORM_udata);
941 
		}
942 
		set_attribute(0, 0);
943 
		c++;
944 
	} while ((dwe_file_t.attr)[c]);
2 7u83 945 
 
6 7u83 946 
	c = 0;
947 
	do {
948 
		long attr = (dwe_set_t.attr)[c];
949 
		set_abbrev_tag(&dwe_set_t, c, DW_TAG_set_type, 0);
950 
		if (attr & H_SP) {
951 
			set_attribute(DW_AT_specification, DW_FORM_ref_addr);
952 
		}
953 
		if (attr & H_DC) {
954 
			set_attribute(DW_AT_declaration, DW_FORM_flag);
955 
		}
956 
		if (attr & H_TP) {
957 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
958 
		}
959 
		if (attr & H_SZ) {
960 
			set_attribute(DW_AT_byte_size, DW_FORM_udata);
961 
		}
962 
		set_attribute(0, 0);
963 
		c++;
964 
	} while ((dwe_set_t.attr)[c]);
2 7u83 965 
 
6 7u83 966 
	c = 0;
967 
	do {
968 
		long attr = (dwe_fixpt_t.attr)[c];
969 
		set_abbrev_tag(&dwe_fixpt_t, c, DW_TAG_DD_fixed_point_type, 0);
970 
		set_attribute(DW_AT_type, DW_FORM_ref_addr);
971 
		set_attribute(DW_AT_DD_small_value, DW_FORM_indirect);
972 
		if (attr & H_DF) {
973 
			set_attribute(DW_AT_DD_delta, DW_FORM_indirect);
974 
		}
975 
		if (attr & H_DS) {
976 
			set_attribute(DW_AT_DD_digits, DW_FORM_indirect);
977 
		}
978 
		set_attribute(0, 0);
979 
		c++;
980 
	} while ((dwe_fixpt_t.attr)[c]);
2 7u83 981 
 
6 7u83 982 
	set_abbrev_tag(&dwe_fldg_t, 0, DW_TAG_DD_floating_digits_type, 0);
983 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
984 
	set_attribute(DW_AT_DD_digits, DW_FORM_indirect);
985 
	set_attribute(0, 0);
2 7u83 986 
 
6 7u83 987 
	set_abbrev_tag(&dwe_modular_t, 0, DW_TAG_DD_modular_type, 0);
988 
	set_attribute(DW_AT_type, DW_FORM_ref_addr);
989 
	set_attribute(DW_AT_count, DW_FORM_indirect);
990 
	set_attribute(0, 0);
2 7u83 991 
 
6 7u83 992 
	struct_abbrev(&dwe_task_t, DW_TAG_DD_task_type);
2 7u83 993 
 
6 7u83 994 
	struct_abbrev(&dwe_synch_t, DW_TAG_DD_synchronized_type);
2 7u83 995 
 
6 7u83 996 
	c = 0;
997 
	do {
998 
		long attr = (dwe_entry.attr)[c];
999 
		set_abbrev_tag(&dwe_entry, c, DW_TAG_DD_entry, 1);
1000 
		if (attr & H_NM) {
1001 
			set_attribute(DW_AT_name, DW_FORM_string);
1002 
		}
1003 
		if (attr & H_XY) {
1004 
			set_decl_attributes();
1005 
		}
1006 
		if (attr & H_AC) {
1007 
			set_attribute(DW_AT_accessibility, DW_FORM_data1);
1008 
		}
1009 
		if (attr & H_TP) {
1010 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
1011 
		}
1012 
		if (attr & H_RP) {
1013 
			set_attribute(DW_AT_DD_repn, DW_FORM_indirect);
1014 
		}
1015 
		set_attribute(0, 0);
1016 
		c++;
1017 
	} while ((dwe_entry.attr)[c]);
2 7u83 1018 
 
6 7u83 1019 
	set_abbrev_tag(&dwe_for_unit, 0, DW_TAG_DD_foreign_source, 0);
1020 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1021 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1022 
	set_attribute(DW_AT_import, DW_FORM_ref_addr);
1023 
	set_attribute(0, 0);
2 7u83 1024 
 
6 7u83 1025 
	set_abbrev_tag(&dwe_for_lang, 0, DW_TAG_DD_foreign_source, 0);
1026 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1027 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1028 
	set_attribute(DW_AT_language, DW_FORM_udata);
1029 
	set_attribute(0, 0);
2 7u83 1030 
 
6 7u83 1031 
	set_abbrev_tag(&dwe_call, 0, DW_TAG_DD_subroutine_call, 0);
1032 
	set_attribute(DW_AT_name, DW_FORM_string);
1033 
	set_decl_attributes();
1034 
	set_attribute(DW_AT_DD_call_kind, DW_FORM_udata);
1035 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1036 
	set_attribute(DW_AT_location, DW_FORM_block1);
1037 
	set_attribute(0, 0);
2 7u83 1038 
 
6 7u83 1039 
	c = 0;
1040 
	do {
1041 
		long attr = (dwe_return.attr)[c];
1042 
		set_abbrev_tag(&dwe_return, c, DW_TAG_DD_subroutine_return, 0);
1043 
		if (attr & H_XY) {
1044 
			set_decl_attributes();
1045 
		}
1046 
		if (attr & H_PC) {
1047 
			set_attribute(DW_AT_low_pc, DW_FORM_addr);
1048 
		}
1049 
		if (attr & H_LC) {
1050 
			set_attribute(DW_AT_location, DW_FORM_block1);
1051 
		}
1052 
		set_attribute(0, 0);
1053 
		c++;
1054 
	} while ((dwe_return.attr)[c]);
2 7u83 1055 
 
6 7u83 1056 
	c = 0;
1057 
	do {
1058 
		long attr = (dwe_destruct.attr)[c];
1059 
		set_abbrev_tag(&dwe_destruct, c, DW_TAG_DD_destruct, 1);
1060 
		set_decl_attributes();
1061 
		set_attribute(DW_AT_low_pc, DW_FORM_addr);
1062 
		if (attr & H_TP) {
1063 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
1064 
		}
1065 
		if (attr & H_LC) {
1066 
			set_attribute(DW_AT_location, DW_FORM_block1);
1067 
		}
1068 
		if (attr & H_CV) {
1069 
			set_attribute(DW_AT_const_value, DW_FORM_indirect);
1070 
		}
1071 
		set_attribute(0, 0);
1072 
		c++;
1073 
	} while ((dwe_destruct.attr)[c]);
2 7u83 1074 
 
6 7u83 1075 
	set_abbrev_tag(&dwe_branch, 0, DW_TAG_DD_branch, 1);
1076 
	set_decl_attributes();
1077 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1078 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1079 
	set_attribute(0, 0);
2 7u83 1080 
 
6 7u83 1081 
	set_abbrev_tag(&dwe_branch_0, 0, DW_TAG_DD_branch, 0);
1082 
	set_decl_attributes();
1083 
	set_attribute(0, 0);
2 7u83 1084 
 
6 7u83 1085 
	set_abbrev_tag(&dwe_break, 0, DW_TAG_DD_breakpoint, 0);
1086 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1087 
	set_attribute(0, 0);
2 7u83 1088 
 
6 7u83 1089 
	set_abbrev_tag(&dwe_test, 0, DW_TAG_DD_test, 0);
1090 
	set_decl_attributes();
1091 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1092 
	set_attribute(DW_AT_DD_cont_pc, DW_FORM_addr);
1093 
	set_attribute(DW_AT_DD_jump_pc, DW_FORM_addr);
1094 
	set_attribute(0, 0);
2 7u83 1095 
 
6 7u83 1096 
	set_abbrev_tag(&dwe_test_0, 0, DW_TAG_DD_test, 0);
1097 
	set_decl_attributes();
1098 
	set_attribute(0, 0);
2 7u83 1099 
 
6 7u83 1100 
	set_abbrev_tag(&dwe_jump, 0, DW_TAG_DD_jump, 0);
1101 
	set_decl_attributes();
1102 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1103 
	set_attribute(DW_AT_DD_jump_pc, DW_FORM_addr);
1104 
	set_attribute(0, 0);
2 7u83 1105 
 
6 7u83 1106 
	set_abbrev_tag(&dwe_jump_0, 0, DW_TAG_DD_jump, 0);
1107 
	set_decl_attributes();
1108 
	set_attribute(0, 0);
2 7u83 1109 
 
6 7u83 1110 
	set_abbrev_tag(&dwe_lj, 0, DW_TAG_DD_long_jump, 0);
1111 
	set_decl_attributes();
1112 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1113 
	set_attribute(DW_AT_location, DW_FORM_block1);
1114 
	set_attribute(0, 0);
2 7u83 1115 
 
6 7u83 1116 
	set_abbrev_tag(&dwe_lj_0, 0, DW_TAG_DD_long_jump, 0);
1117 
	set_decl_attributes();
1118 
	set_attribute(0, 0);
2 7u83 1119 
 
6 7u83 1120 
	c = 0;
1121 
	do {
1122 
		long attr = (dwe_throw.attr)[c];
1123 
		set_abbrev_tag(&dwe_throw, c, DW_TAG_DD_throw, 0);
1124 
		if (attr & H_XY) {
1125 
			set_decl_attributes();
1126 
		}
1127 
		if (attr & H_TP) {
1128 
			set_attribute(DW_AT_type, DW_FORM_ref_addr);
1129 
		}
1130 
		if (attr & H_LC) {
1131 
			set_attribute(DW_AT_location, DW_FORM_block1);
1132 
		}
1133 
		if (attr & H_CV) {
1134 
			set_attribute(DW_AT_const_value, DW_FORM_indirect);
1135 
		}
1136 
		set_attribute(0, 0);
1137 
		c++;
1138 
	} while ((dwe_throw.attr)[c]);
2 7u83 1139 
 
6 7u83 1140 
	set_abbrev_tag(&dwe_barrier, 0, DW_TAG_DD_entry_barrier, 0);
1141 
	set_decl_attributes();
1142 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1143 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1144 
	set_attribute(0, 0);
2 7u83 1145 
 
6 7u83 1146 
	set_abbrev_tag(&dwe_select, 0, DW_TAG_DD_select, 1);
1147 
	set_decl_attributes();
1148 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1149 
	set_attribute(0, 0);
2 7u83 1150 
 
6 7u83 1151 
	set_abbrev_tag(&dwe_accept, 0, DW_TAG_DD_accept, 0);
1152 
	set_decl_attributes();
1153 
	set_attribute(DW_AT_DD_alt, DW_FORM_flag);
1154 
	set_attribute(DW_AT_DD_entry_spec, DW_FORM_ref_addr);
1155 
	set_attribute(0, 0);
2 7u83 1156 
 
6 7u83 1157 
	set_abbrev_tag(&dwe_accept_c, 0, DW_TAG_DD_accept, 1);
1158 
	set_decl_attributes();
1159 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1160 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1161 
	set_attribute(DW_AT_DD_alt, DW_FORM_flag);
1162 
	set_attribute(DW_AT_DD_entry_spec, DW_FORM_ref_addr);
1163 
	set_attribute(0, 0);
2 7u83 1164 
 
6 7u83 1165 
	set_abbrev_tag(&dwe_rts, 0, DW_TAG_DD_rts_call, 0);
1166 
	set_decl_attributes();
1167 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1168 
	set_attribute(DW_AT_DD_alt, DW_FORM_flag);
1169 
	set_attribute(DW_AT_DD_call_kind, DW_FORM_udata);
1170 
	set_attribute(0, 0);
2 7u83 1171 
 
6 7u83 1172 
	set_abbrev_tag(&dwe_rts_en, 0, DW_TAG_DD_rts_call, 0);
1173 
	set_decl_attributes();
1174 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1175 
	set_attribute(DW_AT_DD_alt, DW_FORM_flag);
1176 
	set_attribute(DW_AT_DD_entry_spec, DW_FORM_ref_addr);
1177 
	set_attribute(DW_AT_DD_call_kind, DW_FORM_udata);
1178 
	set_attribute(0, 0);
2 7u83 1179 
 
6 7u83 1180 
	set_abbrev_tag(&dwe_sel_alt, 0, DW_TAG_DD_select_alternative, 1);
1181 
	set_decl_attributes();
1182 
	set_attribute(DW_AT_DD_alt_kind, DW_FORM_udata);
1183 
	set_attribute(DW_AT_DD_alt_no, DW_FORM_indirect);
1184 
	set_attribute(0, 0);
2 7u83 1185 
 
6 7u83 1186 
	set_abbrev_tag(&dwe_sel_alt_c, 0, DW_TAG_DD_select_alternative, 1);
1187 
	set_decl_attributes();
1188 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1189 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1190 
	set_attribute(DW_AT_DD_alt_kind, DW_FORM_udata);
1191 
	set_attribute(DW_AT_DD_alt_no, DW_FORM_indirect);
1192 
	set_attribute(0, 0);
2 7u83 1193 
 
6 7u83 1194 
	set_abbrev_tag(&dwe_sel_guard, 0, DW_TAG_DD_select_guard, 1);
1195 
	set_decl_attributes();
1196 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1197 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1198 
	set_attribute(0, 0);
2 7u83 1199 
 
6 7u83 1200 
	set_abbrev_tag(&dwe_asynchsel, 0, DW_TAG_DD_asynchronous_select, 1);
1201 
	set_decl_attributes();
1202 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1203 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1204 
	set_attribute(0, 0);
2 7u83 1205 
 
6 7u83 1206 
	set_abbrev_tag(&dwe_trigger, 0, DW_TAG_DD_triggering_alternate, 1);
1207 
	set_decl_attributes();
1208 
	set_attribute(DW_AT_DD_alt_kind, DW_FORM_udata);
1209 
	set_attribute(0, 0);
2 7u83 1210 
 
6 7u83 1211 
	set_abbrev_tag(&dwe_trigger_c, 0, DW_TAG_DD_triggering_alternate, 1);
1212 
	set_decl_attributes();
1213 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1214 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1215 
	set_attribute(DW_AT_DD_alt_kind, DW_FORM_udata);
1216 
	set_attribute(0, 0);
2 7u83 1217 
 
6 7u83 1218 
	set_abbrev_tag(&dwe_abort_pt, 0, DW_TAG_DD_abortable_part, 0);
1219 
	set_decl_attributes();
1220 
	set_attribute(0, 0);
2 7u83 1221 
 
6 7u83 1222 
	set_abbrev_tag(&dwe_abort_ptc, 0, DW_TAG_DD_abortable_part, 1);
1223 
	set_decl_attributes();
1224 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1225 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1226 
	set_attribute(0, 0);
2 7u83 1227 
 
6 7u83 1228 
	set_abbrev_tag(&dwe_requeue, 0, DW_TAG_DD_requeue, 1);
1229 
	set_decl_attributes();
1230 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1231 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1232 
	set_attribute(DW_AT_DD_entry_spec, DW_FORM_ref_addr);
1233 
	set_attribute(DW_AT_DD_abort, DW_FORM_flag);
1234 
	set_attribute(0, 0);
2 7u83 1235 
 
6 7u83 1236 
	set_abbrev_tag(&dwe_unknown_t, 0, DW_TAG_DD_incomplete_type, 0);
1237 
	set_attribute(0, 0);
2 7u83 1238 
 
6 7u83 1239 
	set_abbrev_tag(&dwe_span, 0, DW_TAG_DD_source_span, 1);
1240 
	set_attribute(0, 0);
2 7u83 1241 
 
6 7u83 1242 
	set_abbrev_tag(&dwe_span_strt, 0, DW_TAG_DD_source_start, 0);
1243 
	set_decl_attributes();
1244 
	set_attribute(0, 0);
2 7u83 1245 
 
6 7u83 1246 
	set_abbrev_tag(&dwe_span_end, 0, DW_TAG_DD_source_end, 0);
1247 
	set_decl_attributes();
1248 
	set_attribute(0, 0);
2 7u83 1249 
 
6 7u83 1250 
	set_abbrev_tag(&dwe_absent, 0, DW_TAG_DD_absent_code, 1);
1251 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1252 
	set_attribute(0, 0);
2 7u83 1253 
 
6 7u83 1254 
	set_abbrev_tag(&dwe_absent_r, 0, DW_TAG_DD_absent_code, 1);
1255 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1256 
	set_attribute(DW_AT_DD_optim_ref, DW_FORM_ref_addr);
1257 
	set_attribute(0, 0);
2 7u83 1258 
 
6 7u83 1259 
	set_abbrev_tag(&dwe_absent_x, 0, DW_TAG_DD_absent_code, 0);
1260 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1261 
	set_decl_attributes();
1262 
	set_attribute(0, 0);
2 7u83 1263 
 
6 7u83 1264 
	set_abbrev_tag(&dwe_absent_xr, 0, DW_TAG_DD_absent_code, 0);
1265 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1266 
	set_attribute(DW_AT_DD_optim_ref, DW_FORM_ref_addr);
1267 
	set_decl_attributes();
1268 
	set_attribute(0, 0);
2 7u83 1269 
 
6 7u83 1270 
	set_abbrev_tag(&dwe_displaced, 0, DW_TAG_DD_absent_code, 0);
1271 
	set_attribute(DW_AT_DD_optim_ref, DW_FORM_ref_addr);
1272 
	set_attribute(0, 0);
2 7u83 1273 
 
6 7u83 1274 
	set_abbrev_tag(&dwe_displ_x, 0, DW_TAG_DD_absent_code, 0);
1275 
	set_attribute(DW_AT_DD_optim_ref, DW_FORM_ref_addr);
1276 
	set_decl_attributes();
1277 
	set_attribute(0, 0);
2 7u83 1278 
 
6 7u83 1279 
	set_abbrev_tag(&dwe_moved, 0, DW_TAG_DD_moved_code, 1);
1280 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1281 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1282 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1283 
	set_attribute(0, 0);
2 7u83 1284 
 
6 7u83 1285 
	set_abbrev_tag(&dwe_moved_r, 0, DW_TAG_DD_moved_code, 1);
1286 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1287 
	set_attribute(DW_AT_DD_optim_ref, DW_FORM_ref_addr);
1288 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1289 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1290 
	set_attribute(0, 0);
2 7u83 1291 
 
6 7u83 1292 
	set_abbrev_tag(&dwe_moved_x, 0, DW_TAG_DD_moved_code, 1);
1293 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1294 
	set_attribute(0, 0);
2 7u83 1295 
 
6 7u83 1296 
	set_abbrev_tag(&dwe_moved_xr, 0, DW_TAG_DD_moved_code, 1);
1297 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1298 
	set_attribute(DW_AT_DD_optim_ref, DW_FORM_ref_addr);
1299 
	set_attribute(0, 0);
2 7u83 1300 
 
6 7u83 1301 
	set_abbrev_tag(&dwe_optim, 0, DW_TAG_DD_optimisation_block, 1);
1302 
	set_attribute(DW_AT_DD_optimisation_kind, DW_FORM_udata);
1303 
	set_attribute(DW_AT_low_pc, DW_FORM_addr);
1304 
	set_attribute(DW_AT_high_pc, DW_FORM_addr);
1305 
	set_attribute(DW_AT_DD_obj_noassgn, DW_FORM_block2);
1306 
	set_attribute(DW_AT_DD_obj_assgn, DW_FORM_block2);
1307 
	set_attribute(0, 0);
2 7u83 1308 
 
6 7u83 1309 
	out8();
1310 
	outn((long)0);
1311 
	d_outnl();
1312 
	exit_section();
1313 
	return;
2 7u83 1314 
}