Bug Summary

File:build/gcc/dbxout.c
Warning:line 1027, column 7
Value stored to 'used_ltext_label_name' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name dbxout.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-8h8s_7.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c
1/* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987-2021 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20
21/* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
29
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
34
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
41
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
46 end of its "name".
47
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
51 See `dbxout_symbol'.
52
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
57
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
63
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
66
67 For more on data type definitions, see `dbxout_type'. */
68
69#include "config.h"
70#include "system.h"
71#include "coretypes.h"
72#include "target.h"
73#include "function.h"
74#include "rtl.h"
75#include "tree.h"
76#include "memmodel.h"
77#include "tm_p.h"
78#include "stringpool.h"
79#include "insn-config.h"
80#include "emit-rtl.h"
81#include "cgraph.h"
82#include "diagnostic-core.h"
83#include "fold-const.h"
84#include "varasm.h"
85#include "stor-layout.h"
86#include "reload.h"
87#include "output.h"
88#include "dbxout.h"
89#include "toplev.h"
90#include "debug.h"
91#include "common/common-target.h"
92#include "langhooks.h"
93#include "expr.h"
94#include "file-prefix-map.h" /* remap_debug_filename() */
95
96#ifdef XCOFF_DEBUGGING_INFO
97#include "xcoffout.h"
98#endif
99
100#ifndef ASM_STABS_OP"\t.stabs\t"
101# ifdef XCOFF_DEBUGGING_INFO
102# define ASM_STABS_OP"\t.stabs\t" "\t.stabx\t"
103# else
104# define ASM_STABS_OP"\t.stabs\t" "\t.stabs\t"
105# endif
106#endif
107
108#ifndef ASM_STABN_OP"\t.stabn\t"
109#define ASM_STABN_OP"\t.stabn\t" "\t.stabn\t"
110#endif
111
112#ifndef ASM_STABD_OP"\t.stabd\t"
113#define ASM_STABD_OP"\t.stabd\t" "\t.stabd\t"
114#endif
115
116#ifndef DBX_TYPE_DECL_STABS_CODEN_LSYM
117#define DBX_TYPE_DECL_STABS_CODEN_LSYM N_LSYM
118#endif
119
120#ifndef DBX_STATIC_CONST_VAR_CODEN_FUN
121#define DBX_STATIC_CONST_VAR_CODEN_FUN N_FUN
122#endif
123
124#ifndef DBX_REGPARM_STABS_CODEN_RSYM
125#define DBX_REGPARM_STABS_CODEN_RSYM N_RSYM
126#endif
127
128#ifndef DBX_REGPARM_STABS_LETTER'P'
129#define DBX_REGPARM_STABS_LETTER'P' 'P'
130#endif
131
132#ifndef NO_DBX_FUNCTION_END0
133#define NO_DBX_FUNCTION_END0 0
134#endif
135
136#ifndef NO_DBX_BNSYM_ENSYM0
137#define NO_DBX_BNSYM_ENSYM0 0
138#endif
139
140#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY0
141#define NO_DBX_MAIN_SOURCE_DIRECTORY0 0
142#endif
143
144#ifndef DBX_BLOCKS_FUNCTION_RELATIVE1
145#define DBX_BLOCKS_FUNCTION_RELATIVE1 0
146#endif
147
148#ifndef DBX_LINES_FUNCTION_RELATIVE1
149#define DBX_LINES_FUNCTION_RELATIVE1 0
150#endif
151
152#ifndef DBX_CONTIN_LENGTH0
153#define DBX_CONTIN_LENGTH0 80
154#endif
155
156#ifndef DBX_CONTIN_CHAR'\\'
157#define DBX_CONTIN_CHAR'\\' '\\'
158#endif
159
160enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
161
162/* Structure recording information about a C data type.
163 The status element says whether we have yet output
164 the definition of the type. TYPE_XREF says we have
165 output it as a cross-reference only.
166 The file_number and type_number elements are used if DBX_USE_BINCL
167 is defined. */
168
169struct GTY(()) typeinfo {
170 enum typestatus status;
171 int file_number;
172 int type_number;
173};
174
175/* Vector recording information about C data types.
176 When we first notice a data type (a tree node),
177 we assign it a number using next_type_number.
178 That is its index in this vector. */
179
180static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
181
182/* Number of elements of space allocated in `typevec'. */
183
184static GTY(()) int typevec_len;
185
186/* In dbx output, each type gets a unique number.
187 This is the number for the next type output.
188 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
189
190static GTY(()) int next_type_number;
191
192/* The C front end may call dbxout_symbol before dbxout_init runs.
193 We save all such decls in this list and output them when we get
194 to dbxout_init. */
195
196static GTY(()) tree preinit_symbols;
197
198enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
199
200/* When using N_BINCL in dbx output, each type number is actually a
201 pair of the file number and the type number within the file.
202 This is a stack of input files. */
203
204struct dbx_file
205{
206 struct dbx_file *next;
207 int file_number;
208 int next_type_number;
209 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
210 const char *pending_bincl_name; /* Name of bincl. */
211 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
212};
213
214/* This is the top of the stack.
215
216 This is not saved for PCH, because restoring a PCH should not change it.
217 next_file_number does have to be saved, because the PCH may use some
218 file numbers; however, just before restoring a PCH, next_file_number
219 should always be 0 because we should not have needed any file numbers
220 yet. */
221
222#if (defined (DBX_DEBUGGING_INFO1) || defined (XCOFF_DEBUGGING_INFO)) \
223 && defined (DBX_USE_BINCL)
224static struct dbx_file *current_file;
225#endif
226
227/* This is the next file number to use. */
228
229static GTY(()) int next_file_number;
230
231/* A counter for dbxout_function_end. */
232
233static GTY(()) int scope_labelno;
234
235/* A counter for dbxout_source_line. */
236
237static GTY(()) int dbxout_source_line_counter;
238
239/* Number for the next N_SOL filename stabs label. The number 0 is reserved
240 for the N_SO filename stabs label. */
241
242static GTY(()) int source_label_number = 1;
243
244/* Last source file name mentioned in a NOTE insn. */
245
246static GTY(()) const char *lastfile;
247
248/* Last line number mentioned in a NOTE insn. */
249
250static GTY(()) unsigned int lastlineno;
251
252/* Used by PCH machinery to detect if 'lastfile' should be reset to
253 base_input_file. */
254static GTY(()) int lastfile_is_base;
255
256/* Typical USG systems don't have stab.h, and they also have
257 no use for DBX-format debugging info. */
258
259#if defined (DBX_DEBUGGING_INFO1) || defined (XCOFF_DEBUGGING_INFO)
260
261#ifdef DBX_USE_BINCL
262/* If zero then there is no pending BINCL. */
263static int pending_bincls = 0;
264#endif
265
266/* The original input file name. */
267static const char *base_input_file;
268
269#ifdef DEBUG_SYMS_TEXT
270#define FORCE_TEXT switch_to_section (current_function_section ())
271#else
272#define FORCE_TEXT
273#endif
274
275#include "gstab.h"
276
277/* 1 if PARM is passed to this function in memory. */
278
279#define PARM_PASSED_IN_MEMORY(PARM)((((enum rtx_code) (((tree_check ((PARM), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 279, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
))->code) == MEM))
\
280 (MEM_P (DECL_INCOMING_RTL (PARM))(((enum rtx_code) (((tree_check ((PARM), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 280, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
))->code) == MEM)
)
281
282/* A C expression for the integer offset value of an automatic variable
283 (N_LSYM) having address X (an RTX). */
284#ifndef DEBUGGER_AUTO_OFFSET
285#define DEBUGGER_AUTO_OFFSET(X)(((enum rtx_code) (X)->code) == PLUS ? (((((X)->u.fld[1
]).rt_rtx))->u.hwint[0]) : 0)
\
286 (GET_CODE (X)((enum rtx_code) (X)->code) == PLUS ? INTVAL (XEXP (X, 1))(((((X)->u.fld[1]).rt_rtx))->u.hwint[0]) : 0)
287#endif
288
289/* A C expression for the integer offset value of an argument (N_PSYM)
290 having address X (an RTX). The nominal offset is OFFSET.
291 Note that we use OFFSET + 0 here to avoid the self-assign warning
292 when the macro is called in a context like
293 number = DEBUGGER_ARG_OFFSET(number, X) */
294#ifndef DEBUGGER_ARG_OFFSET
295#define DEBUGGER_ARG_OFFSET(OFFSET, X)(OFFSET + 0) (OFFSET + 0)
296#endif
297
298/* This obstack holds the stab string currently being constructed. We
299 build it up here, then write it out, so we can split long lines up
300 properly (see dbxout_finish_complex_stabs). */
301static struct obstack stabstr_ob;
302static size_t stabstr_last_contin_point;
303
304#ifdef DBX_USE_BINCL
305static void emit_bincl_stab (const char *c);
306static void emit_pending_bincls (void);
307#endif
308static inline void emit_pending_bincls_if_required (void);
309
310static void dbxout_init (const char *);
311
312static void dbxout_finish (const char *);
313static void dbxout_start_source_file (unsigned, const char *);
314static void dbxout_end_source_file (unsigned);
315static void dbxout_typedefs (tree);
316static void dbxout_type_index (tree);
317static void dbxout_args (tree);
318static void dbxout_type_fields (tree);
319static void dbxout_type_method_1 (tree);
320static void dbxout_type_methods (tree);
321static void dbxout_range_type (tree, tree, tree);
322static void dbxout_type (tree, int);
323static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
324static bool is_fortran (void);
325static void dbxout_type_name (tree);
326static void dbxout_class_name_qualifiers (tree);
327static int dbxout_symbol_location (tree, tree, const char *, rtx);
328static void dbxout_symbol_name (tree, const char *, int);
329static void dbxout_common_name (tree, const char *, stab_code_type);
330static const char *dbxout_common_check (tree, int *);
331static void dbxout_early_global_decl (tree);
332static void dbxout_late_global_decl (tree);
333static void dbxout_type_decl (tree, int);
334static void dbxout_handle_pch (unsigned);
335static void debug_free_queue (void);
336
337/* The debug hooks structure. */
338#if defined (DBX_DEBUGGING_INFO1)
339
340static void dbxout_source_line (unsigned int, unsigned int, const char *,
341 int, bool);
342static void dbxout_switch_text_section (void);
343static void dbxout_begin_prologue (unsigned int, unsigned int, const char *);
344static void dbxout_source_file (const char *);
345static void dbxout_function_end (tree);
346static void dbxout_begin_function (tree);
347static void dbxout_begin_block (unsigned, unsigned);
348static void dbxout_end_block (unsigned, unsigned);
349static void dbxout_function_decl (tree);
350
351const struct gcc_debug_hooks dbx_debug_hooks =
352{
353 dbxout_init,
354 dbxout_finish,
355 debug_nothing_charstar,
356 debug_nothing_void,
357 debug_nothing_int_charstar,
358 debug_nothing_int_charstar,
359 dbxout_start_source_file,
360 dbxout_end_source_file,
361 dbxout_begin_block,
362 dbxout_end_block,
363 debug_true_const_tree, /* ignore_block */
364 dbxout_source_line, /* source_line */
365 dbxout_begin_prologue, /* begin_prologue */
366 debug_nothing_int_charstar, /* end_prologue */
367 debug_nothing_int_charstar, /* begin_epilogue */
368 debug_nothing_int_charstar, /* end_epilogue */
369#ifdef DBX_FUNCTION_FIRST
370 dbxout_begin_function,
371#else
372 debug_nothing_tree, /* begin_function */
373#endif
374 debug_nothing_int, /* end_function */
375 debug_nothing_tree, /* register_main_translation_unit */
376 dbxout_function_decl,
377 dbxout_early_global_decl, /* early_global_decl */
378 dbxout_late_global_decl, /* late_global_decl */
379 dbxout_type_decl, /* type_decl */
380 debug_nothing_tree_tree_tree_bool_bool,/* imported_module_or_decl */
381 debug_false_tree_charstarstar_uhwistar,/* die_ref_for_decl */
382 debug_nothing_tree_charstar_uhwi, /* register_external_die */
383 debug_nothing_tree, /* deferred_inline_function */
384 debug_nothing_tree, /* outlining_inline_function */
385 debug_nothing_rtx_code_label, /* label */
386 dbxout_handle_pch, /* handle_pch */
387 debug_nothing_rtx_insn, /* var_location */
388 debug_nothing_tree, /* inline_entry */
389 debug_nothing_tree, /* size_function */
390 dbxout_switch_text_section, /* switch_text_section */
391 debug_nothing_tree_tree, /* set_name */
392 0, /* start_end_main_source_file */
393 TYPE_SYMTAB_IS_ADDRESS(0) /* tree_type_symtab_field */
394};
395#endif /* DBX_DEBUGGING_INFO */
396
397#if defined (XCOFF_DEBUGGING_INFO)
398const struct gcc_debug_hooks xcoff_debug_hooks =
399{
400 dbxout_init,
401 dbxout_finish,
402 debug_nothing_charstar,
403 debug_nothing_void,
404 debug_nothing_int_charstar,
405 debug_nothing_int_charstar,
406 dbxout_start_source_file,
407 dbxout_end_source_file,
408 xcoffout_begin_block,
409 xcoffout_end_block,
410 debug_true_const_tree, /* ignore_block */
411 xcoffout_source_line,
412 xcoffout_begin_prologue, /* begin_prologue */
413 debug_nothing_int_charstar, /* end_prologue */
414 debug_nothing_int_charstar, /* begin_epilogue */
415 xcoffout_end_epilogue,
416 debug_nothing_tree, /* begin_function */
417 xcoffout_end_function,
418 debug_nothing_tree, /* register_main_translation_unit */
419 debug_nothing_tree, /* function_decl */
420 dbxout_early_global_decl, /* early_global_decl */
421 dbxout_late_global_decl, /* late_global_decl */
422 dbxout_type_decl, /* type_decl */
423 debug_nothing_tree_tree_tree_bool_bool,/* imported_module_or_decl */
424 debug_false_tree_charstarstar_uhwistar,/* die_ref_for_decl */
425 debug_nothing_tree_charstar_uhwi, /* register_external_die */
426 debug_nothing_tree, /* deferred_inline_function */
427 debug_nothing_tree, /* outlining_inline_function */
428 debug_nothing_rtx_code_label, /* label */
429 dbxout_handle_pch, /* handle_pch */
430 debug_nothing_rtx_insn, /* var_location */
431 debug_nothing_tree, /* inline_entry */
432 debug_nothing_tree, /* size_function */
433 debug_nothing_void, /* switch_text_section */
434 debug_nothing_tree_tree, /* set_name */
435 0, /* start_end_main_source_file */
436 TYPE_SYMTAB_IS_ADDRESS(0) /* tree_type_symtab_field */
437};
438#endif /* XCOFF_DEBUGGING_INFO */
439
440/* Numeric formatting helper macro. Note that this does not handle
441 hexadecimal. */
442#define NUMBER_FMT_LOOP(P, NUM, BASE)do { int digit = NUM % BASE; NUM /= BASE; *--P = digit + '0';
} while (NUM > 0)
\
443 do \
444 { \
445 int digit = NUM % BASE; \
446 NUM /= BASE; \
447 *--P = digit + '0'; \
448 } \
449 while (NUM > 0)
450
451/* Utility: write a decimal integer NUM to asm_out_file. */
452void
453dbxout_int (int num)
454{
455 char buf[64];
456 char *p = buf + sizeof buf;
457 unsigned int unum;
458
459 if (num == 0)
460 {
461 putc ('0', asm_out_file);
462 return;
463 }
464 if (num < 0)
465 {
466 putc ('-', asm_out_file);
467 unum = -(unsigned int) num;
468 }
469 else
470 unum = num;
471
472 NUMBER_FMT_LOOP (p, unum, 10)do { int digit = unum % 10; unum /= 10; *--p = digit + '0'; }
while (unum > 0)
;
473
474 while (p < buf + sizeof buf)
475 {
476 putc (*p, asm_out_file);
477 p++;
478 }
479}
480
481
482/* Primitives for emitting simple stabs directives. All other stabs
483 routines should use these functions instead of directly emitting
484 stabs. They are exported because machine-dependent code may need
485 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
486 forwards to code in CPU.c. */
487
488/* The following functions should all be called immediately after one
489 of the dbxout_begin_stab* functions (below). They write out
490 various things as the value of a stab. */
491
492/* Write out a literal zero as the value of a stab. */
493void
494dbxout_stab_value_zero (void)
495{
496 fputs ("0\n", asm_out_file);
497}
498
499/* Write out the label LABEL as the value of a stab. */
500void
501dbxout_stab_value_label (const char *label)
502{
503 assemble_name (asm_out_file, label);
504 putc ('\n', asm_out_file);
505}
506
507/* Write out the difference of two labels, LABEL - BASE, as the value
508 of a stab. */
509void
510dbxout_stab_value_label_diff (const char *label, const char *base)
511{
512 assemble_name (asm_out_file, label);
513 putc ('-', asm_out_file);
514 assemble_name (asm_out_file, base);
515 putc ('\n', asm_out_file);
516}
517
518/* Write out an internal label as the value of a stab, and immediately
519 emit that internal label. This should be used only when
520 dbxout_stabd will not work. STEM is the name stem of the label,
521 COUNTERP is a pointer to a counter variable which will be used to
522 guarantee label uniqueness. */
523void
524dbxout_stab_value_internal_label (const char *stem, int *counterp)
525{
526 char label[100];
527 int counter = counterp ? (*counterp)++ : 0;
528
529 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter)do { char *__p; (label)[0] = '*'; (label)[1] = '.'; __p = stpcpy
(&(label)[2], stem); sprint_ul (__p, (unsigned long) (counter
)); } while (0)
;
530 dbxout_stab_value_label (label);
531 targetm.asm_out.internal_label (asm_out_file, stem, counter);
532}
533
534/* Write out the difference between BASE and an internal label as the
535 value of a stab, and immediately emit that internal label. STEM and
536 COUNTERP are as for dbxout_stab_value_internal_label. */
537void
538dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
539 const char *base)
540{
541 char label[100];
542 int counter = counterp ? (*counterp)++ : 0;
543
544 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter)do { char *__p; (label)[0] = '*'; (label)[1] = '.'; __p = stpcpy
(&(label)[2], stem); sprint_ul (__p, (unsigned long) (counter
)); } while (0)
;
545 dbxout_stab_value_label_diff (label, base);
546 targetm.asm_out.internal_label (asm_out_file, stem, counter);
547}
548
549/* The following functions produce specific kinds of stab directives. */
550
551/* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
552void
553dbxout_stabd (int stype, int sdesc)
554{
555 fputs (ASM_STABD_OP"\t.stabd\t", asm_out_file);
556 dbxout_int (stype);
557 fputs (",0,", asm_out_file);
558 dbxout_int (sdesc);
559 putc ('\n', asm_out_file);
560}
561
562/* Write a .stabn directive with type STYPE. This function stops
563 short of emitting the value field, which is the responsibility of
564 the caller (normally it will be either a symbol or the difference
565 of two symbols). */
566
567void
568dbxout_begin_stabn (int stype)
569{
570 fputs (ASM_STABN_OP"\t.stabn\t", asm_out_file);
571 dbxout_int (stype);
572 fputs (",0,0,", asm_out_file);
573}
574
575/* Write a .stabn directive with type N_SLINE and desc LINE. As above,
576 the value field is the responsibility of the caller. */
577void
578dbxout_begin_stabn_sline (int lineno)
579{
580 fputs (ASM_STABN_OP"\t.stabn\t", asm_out_file);
581 dbxout_int (N_SLINE);
582 fputs (",0,", asm_out_file);
583 dbxout_int (lineno);
584 putc (',', asm_out_file);
585}
586
587/* Begin a .stabs directive with string "", type STYPE, and desc and
588 other fields 0. The value field is the responsibility of the
589 caller. This function cannot be used for .stabx directives. */
590void
591dbxout_begin_empty_stabs (int stype)
592{
593 fputs (ASM_STABS_OP"\t.stabs\t", asm_out_file);
594 fputs ("\"\",", asm_out_file);
595 dbxout_int (stype);
596 fputs (",0,0,", asm_out_file);
597}
598
599/* Begin a .stabs directive with string STR, type STYPE, and desc 0.
600 The value field is the responsibility of the caller. */
601void
602dbxout_begin_simple_stabs (const char *str, int stype)
603{
604 fputs (ASM_STABS_OP"\t.stabs\t", asm_out_file);
605 output_quoted_string (asm_out_file, str);
606 putc (',', asm_out_file);
607 dbxout_int (stype);
608 fputs (",0,0,", asm_out_file);
609}
610
611/* As above but use SDESC for the desc field. */
612void
613dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
614{
615 fputs (ASM_STABS_OP"\t.stabs\t", asm_out_file);
616 output_quoted_string (asm_out_file, str);
617 putc (',', asm_out_file);
618 dbxout_int (stype);
619 fputs (",0,", asm_out_file);
620 dbxout_int (sdesc);
621 putc (',', asm_out_file);
622}
623
624/* The next set of functions are entirely concerned with production of
625 "complex" .stabs directives: that is, .stabs directives whose
626 strings have to be constructed piecemeal. dbxout_type,
627 dbxout_symbol, etc. use these routines heavily. The string is queued
628 up in an obstack, then written out by dbxout_finish_complex_stabs, which
629 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
630 (You might think it would be more efficient to go straight to stdio
631 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
632 out not to be the case, and anyway this needs fewer #ifdefs.) */
633
634/* Begin a complex .stabs directive. If we can, write the initial
635 ASM_STABS_OP to the asm_out_file. */
636
637static void
638dbxout_begin_complex_stabs (void)
639{
640 emit_pending_bincls_if_required ();
641 FORCE_TEXT;
642 fputs (ASM_STABS_OP"\t.stabs\t", asm_out_file);
643 putc ('"', asm_out_file);
644 gcc_assert (stabstr_last_contin_point == 0)((void)(!(stabstr_last_contin_point == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 644, __FUNCTION__), 0 : 0))
;
645}
646
647/* As above, but do not force text or emit pending bincls. This is
648 used by dbxout_symbol_location, which needs to do something else. */
649static void
650dbxout_begin_complex_stabs_noforcetext (void)
651{
652 fputs (ASM_STABS_OP"\t.stabs\t", asm_out_file);
653 putc ('"', asm_out_file);
654 gcc_assert (stabstr_last_contin_point == 0)((void)(!(stabstr_last_contin_point == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 654, __FUNCTION__), 0 : 0))
;
655}
656
657/* Add CHR, a single character, to the string being built. */
658#define stabstr_C(chr)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (chr))); })
obstack_1grow (&stabstr_ob, chr)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (chr))); })
659
660/* Add STR, a normal C string, to the string being built. */
661#define stabstr_S(str)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (str)); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, str, __len); __o->next_free += __len; (void
) 0; })
obstack_grow (&stabstr_ob, str, strlen (str))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (str)); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, str, __len); __o->next_free += __len; (void
) 0; })
662
663/* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
664#define stabstr_I(id)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 664, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 664, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
obstack_grow (&stabstr_ob, \__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 666, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 665, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
665 IDENTIFIER_POINTER (id), \__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 666, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 665, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
666 IDENTIFIER_LENGTH (id))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 666, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 665, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
667
668/* Add NUM, a signed decimal number, to the string being built. */
669static void
670stabstr_D (HOST_WIDE_INTlong num)
671{
672 char buf[64];
673 char *p = buf + sizeof buf;
674 unsigned HOST_WIDE_INTlong unum;
675
676 if (num == 0)
677 {
678 stabstr_C ('0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('0'))); })
;
679 return;
680 }
681 if (num < 0)
682 {
683 stabstr_C ('-')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('-'))); })
;
684 unum = -(unsigned HOST_WIDE_INTlong) num;
685 }
686 else
687 unum = num;
688
689 NUMBER_FMT_LOOP (p, unum, 10)do { int digit = unum % 10; unum /= 10; *--p = digit + '0'; }
while (unum > 0)
;
690
691 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = ((buf + sizeof buf) - p); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, p, __len); __o->next_free +=
__len; (void) 0; })
;
692}
693
694/* Add NUM, an unsigned decimal number, to the string being built. */
695static void
696stabstr_U (unsigned HOST_WIDE_INTlong num)
697{
698 char buf[64];
699 char *p = buf + sizeof buf;
700 if (num == 0)
701 {
702 stabstr_C ('0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('0'))); })
;
703 return;
704 }
705 NUMBER_FMT_LOOP (p, num, 10)do { int digit = num % 10; num /= 10; *--p = digit + '0'; } while
(num > 0)
;
706 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = ((buf + sizeof buf) - p); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, p, __len); __o->next_free +=
__len; (void) 0; })
;
707}
708
709/* Add CST, an INTEGER_CST tree, to the string being built as an
710 unsigned octal number. This routine handles values which are
711 larger than a single HOST_WIDE_INT. */
712static void
713stabstr_O (tree cst)
714{
715 int prec = TYPE_PRECISION (TREE_TYPE (cst))((tree_class_check ((((contains_struct_check ((cst), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 715, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 715, __FUNCTION__))->type_common.precision)
;
716 int res_pres = prec % 3;
717 int i;
718 unsigned int digit;
719
720 /* Leading zero for base indicator. */
721 stabstr_C ('0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('0'))); })
;
722
723 /* If the value is zero, the base indicator will serve as the value
724 all by itself. */
725 if (wi::to_wide (cst) == 0)
726 return;
727
728 /* GDB wants constants with no extra leading "1" bits, so
729 we need to remove any sign-extension that might be
730 present. */
731 if (res_pres == 1)
732 {
733 digit = wi::extract_uhwi (wi::to_wide (cst), prec - 1, 1);
734 stabstr_C ('0' + digit)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('0' + digit))
); })
;
735 }
736 else if (res_pres == 2)
737 {
738 digit = wi::extract_uhwi (wi::to_wide (cst), prec - 2, 2);
739 stabstr_C ('0' + digit)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('0' + digit))
); })
;
740 }
741
742 prec -= res_pres;
743 for (i = prec - 3; i >= 0; i = i - 3)
744 {
745 digit = wi::extract_uhwi (wi::to_wide (cst), i, 3);
746 stabstr_C ('0' + digit)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('0' + digit))
); })
;
747 }
748}
749
750/* Called whenever it is safe to break a stabs string into multiple
751 .stabs directives. If the current string has exceeded the limit
752 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
753 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
754 it is a backslash) and a null character. */
755static inline void
756stabstr_continue (void)
757{
758 if (DBX_CONTIN_LENGTH0 > 0
759 && obstack_object_size (&stabstr_ob)__extension__ ({ struct obstack const *__o = (&stabstr_ob
); (size_t) (__o->next_free - __o->object_base); })
- stabstr_last_contin_point
760 > DBX_CONTIN_LENGTH0)
761 {
762 if (DBX_CONTIN_CHAR'\\' == '\\')
763 obstack_1grow (&stabstr_ob, '\\')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('\\'))); })
;
764 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('\\'))); })
;
765 obstack_1grow (&stabstr_ob, '\0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('\0'))); })
;
766 stabstr_last_contin_point = obstack_object_size (&stabstr_ob)__extension__ ({ struct obstack const *__o = (&stabstr_ob
); (size_t) (__o->next_free - __o->object_base); })
;
767 }
768}
769#define CONTINstabstr_continue () stabstr_continue ()
770
771/* Macro subroutine of dbxout_finish_complex_stabs, which emits
772 all of the arguments to the .stabs directive after the string.
773 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
774 LINE is the source line to write into the desc field (in extended
775 mode); SYM is the symbol itself.
776
777 ADDR, LABEL, and NUMBER are three different ways to represent the
778 stabs value field. At most one of these should be nonzero.
779
780 ADDR is used most of the time; it represents the value as an
781 RTL address constant.
782
783 LABEL is used (currently) only for N_CATCH stabs; it represents
784 the value as a string suitable for assemble_name.
785
786 NUMBER is used when the value is an offset from an implicit base
787 pointer (e.g. for a stack variable), or an index (e.g. for a
788 register variable). It represents the value as a decimal integer. */
789
790#ifndef DBX_FINISH_STABS
791#define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER)do { int line_ = global_options.x_use_gnu_debug_info_extensions
? LINE : 0; dbxout_int (CODE); fputs (",0,", asm_out_file); dbxout_int
(line_); putc (',', asm_out_file); if (ADDR) output_addr_const
(asm_out_file, ADDR); else if (LABEL) assemble_name (asm_out_file
, LABEL); else dbxout_int (NUMBER); putc ('\n', asm_out_file)
; } while (0)
\
792do { \
793 int line_ = use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions ? LINE : 0; \
794 \
795 dbxout_int (CODE); \
796 fputs (",0,", asm_out_file); \
797 dbxout_int (line_); \
798 putc (',', asm_out_file); \
799 if (ADDR) \
800 output_addr_const (asm_out_file, ADDR); \
801 else if (LABEL) \
802 assemble_name (asm_out_file, LABEL); \
803 else \
804 dbxout_int (NUMBER); \
805 putc ('\n', asm_out_file); \
806} while (0)
807#endif
808
809/* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
810 is zero, this has only to emit the close quote and the remainder of
811 the arguments. When it is nonzero, the string has been marshalled in
812 stabstr_ob, and this routine is responsible for breaking it up into
813 DBX_CONTIN_LENGTH-sized chunks.
814
815 SYM is the DECL of the symbol under consideration; it is used only
816 for its DECL_SOURCE_LINE. The other arguments are all passed directly
817 to DBX_FINISH_STABS; see above for details. */
818
819static void
820dbxout_finish_complex_stabs (tree sym, stab_code_type code,
821 rtx addr, const char *label, int number)
822{
823 int line ATTRIBUTE_UNUSED__attribute__ ((__unused__));
824 char *str;
825 size_t len;
826
827 line = sym ? DECL_SOURCE_LINE (sym)((expand_location (((contains_struct_check ((sym), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 827, __FUNCTION__))->decl_minimal.locus))).line)
: 0;
828 if (DBX_CONTIN_LENGTH0 > 0)
829 {
830 char *chunk;
831 size_t chunklen;
832
833 /* Nul-terminate the growing string, then get its size and
834 address. */
835 obstack_1grow (&stabstr_ob, '\0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('\0'))); })
;
836
837 len = obstack_object_size (&stabstr_ob)__extension__ ({ struct obstack const *__o = (&stabstr_ob
); (size_t) (__o->next_free - __o->object_base); })
;
838 chunk = str = XOBFINISH (&stabstr_ob, char *)((char *) __extension__ ({ struct obstack *__o1 = ((&stabstr_ob
)); void *__value = (void *) __o1->object_base; if (__o1->
next_free == __value) __o1->maybe_empty_object = 1; __o1->
next_free = ((sizeof (ptrdiff_t) < sizeof (void *) ? (__o1
->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof
(ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (
char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask
))); if ((size_t) (__o1->next_free - (char *) __o1->chunk
) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk
)) __o1->next_free = __o1->chunk_limit; __o1->object_base
= __o1->next_free; __value; }))
;
839
840 /* Within the buffer are a sequence of NUL-separated strings,
841 each of which is to be written out as a separate stab
842 directive. */
843 for (;;)
844 {
845 chunklen = strlen (chunk);
846 fwrite (chunk, 1, chunklen, asm_out_file);
847 fputs ("\",", asm_out_file);
848
849 /* Must add an extra byte to account for the NUL separator. */
850 chunk += chunklen + 1;
851 len -= chunklen + 1;
852
853 /* Only put a line number on the last stab in the sequence. */
854 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,do { int line_ = global_options.x_use_gnu_debug_info_extensions
? len == 0 ? line : 0 : 0; dbxout_int (code); fputs (",0,", asm_out_file
); dbxout_int (line_); putc (',', asm_out_file); if (addr) output_addr_const
(asm_out_file, addr); else if (label) assemble_name (asm_out_file
, label); else dbxout_int (number); putc ('\n', asm_out_file)
; } while (0)
855 addr, label, number)do { int line_ = global_options.x_use_gnu_debug_info_extensions
? len == 0 ? line : 0 : 0; dbxout_int (code); fputs (",0,", asm_out_file
); dbxout_int (line_); putc (',', asm_out_file); if (addr) output_addr_const
(asm_out_file, addr); else if (label) assemble_name (asm_out_file
, label); else dbxout_int (number); putc ('\n', asm_out_file)
; } while (0)
;
856 if (len == 0)
857 break;
858
859 fputs (ASM_STABS_OP"\t.stabs\t", asm_out_file);
860 putc ('"', asm_out_file);
861 }
862 stabstr_last_contin_point = 0;
863 }
864 else
865 {
866 /* No continuations - we can put the whole string out at once.
867 It is faster to augment the string with the close quote and
868 comma than to do a two-character fputs. */
869 obstack_grow (&stabstr_ob, "\",", 2)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (2); if (__extension__ ({ struct obstack const *__o1
= (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, "\",", __len); __o->next_free += __len; (void
) 0; })
;
870 len = obstack_object_size (&stabstr_ob)__extension__ ({ struct obstack const *__o = (&stabstr_ob
); (size_t) (__o->next_free - __o->object_base); })
;
871 str = XOBFINISH (&stabstr_ob, char *)((char *) __extension__ ({ struct obstack *__o1 = ((&stabstr_ob
)); void *__value = (void *) __o1->object_base; if (__o1->
next_free == __value) __o1->maybe_empty_object = 1; __o1->
next_free = ((sizeof (ptrdiff_t) < sizeof (void *) ? (__o1
->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof
(ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (
char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask
))); if ((size_t) (__o1->next_free - (char *) __o1->chunk
) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk
)) __o1->next_free = __o1->chunk_limit; __o1->object_base
= __o1->next_free; __value; }))
;
872
873 fwrite (str, 1, len, asm_out_file);
874 DBX_FINISH_STABS (sym, code, line, addr, label, number)do { int line_ = global_options.x_use_gnu_debug_info_extensions
? line : 0; dbxout_int (code); fputs (",0,", asm_out_file); dbxout_int
(line_); putc (',', asm_out_file); if (addr) output_addr_const
(asm_out_file, addr); else if (label) assemble_name (asm_out_file
, label); else dbxout_int (number); putc ('\n', asm_out_file)
; } while (0)
;
875 }
876 obstack_free (&stabstr_ob, str)__extension__ ({ struct obstack *__o = (&stabstr_ob); void
*__obj = (void *) (str); if (__obj > (void *) __o->chunk
&& __obj < (void *) __o->chunk_limit) __o->
next_free = __o->object_base = (char *) __obj; else _obstack_free
(__o, __obj); })
;
877}
878
879#if defined (DBX_DEBUGGING_INFO1) || defined (XCOFF_DEBUGGING_INFO)
880
881/* When -gused is used, emit debug info for only used symbols. But in
882 addition to the standard intercepted debug_hooks there are some
883 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
884 dbxout_reg_params. Those routines may also be called from a higher
885 level intercepted routine. So to prevent recording data for an inner
886 call to one of these for an intercept, we maintain an intercept
887 nesting counter (debug_nesting). We only save the intercepted
888 arguments if the nesting is 1. */
889static int debug_nesting = 0;
890
891static tree *symbol_queue;
892static int symbol_queue_index = 0;
893static int symbol_queue_size = 0;
894
895#define DBXOUT_DECR_NESTINGif (--debug_nesting == 0 && symbol_queue_index > 0
) { emit_pending_bincls_if_required (); debug_flush_symbol_queue
(); }
\
896 if (--debug_nesting == 0 && symbol_queue_index > 0) \
897 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
898
899#define DBXOUT_DECR_NESTING_AND_RETURN(x)do {--debug_nesting; return (x);} while (0) \
900 do {--debug_nesting; return (x);} while (0)
901
902#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
903
904#if defined (DBX_DEBUGGING_INFO1)
905
906static void
907dbxout_function_end (tree decl ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
908{
909 char lscope_label_name[100];
910
911 /* The Lscope label must be emitted even if we aren't doing anything
912 else; dbxout_block needs it. */
913 switch_to_section (current_function_section ());
914
915 /* Convert Lscope into the appropriate format for local labels in case
916 the system doesn't insert underscores in front of user generated
917 labels. */
918 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno)do { char *__p; (lscope_label_name)[0] = '*'; (lscope_label_name
)[1] = '.'; __p = stpcpy (&(lscope_label_name)[2], "Lscope"
); sprint_ul (__p, (unsigned long) (scope_labelno)); } while (
0)
;
919 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
920
921 /* The N_FUN tag at the end of the function is a GNU extension,
922 which may be undesirable, and is unnecessary if we do not have
923 named sections. */
924 if (!use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
925 || NO_DBX_FUNCTION_END0
926 || !targetm_common.have_named_sections)
927 return;
928
929 /* By convention, GCC will mark the end of a function with an N_FUN
930 symbol and an empty string. */
931 if (crtl(&x_rtl)->has_bb_partition)
932 {
933 dbxout_begin_empty_stabs (N_FUN);
934 if (in_cold_section_p)
935 dbxout_stab_value_label_diff (crtl(&x_rtl)->subsections.cold_section_end_label,
936 crtl(&x_rtl)->subsections.cold_section_label);
937 else
938 dbxout_stab_value_label_diff (crtl(&x_rtl)->subsections.hot_section_end_label,
939 crtl(&x_rtl)->subsections.hot_section_label);
940 }
941 else
942 {
943 char begin_label[20];
944 /* Reference current function start using LFBB. */
945 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno)do { char *__p; (begin_label)[0] = '*'; (begin_label)[1] = '.'
; __p = stpcpy (&(begin_label)[2], "LFBB"); sprint_ul (__p
, (unsigned long) (scope_labelno)); } while (0)
;
946 dbxout_begin_empty_stabs (N_FUN);
947 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
948 }
949
950 if (!NO_DBX_BNSYM_ENSYM0 && !flag_debug_only_used_symbolsglobal_options.x_flag_debug_only_used_symbols)
951 dbxout_stabd (N_ENSYM, 0);
952}
953#endif /* DBX_DEBUGGING_INFO */
954
955/* Get lang description for N_SO stab. */
956static unsigned int ATTRIBUTE_UNUSED__attribute__ ((__unused__))
957get_lang_number (void)
958{
959 const char *language_string = lang_hooks.name;
960 if (lang_GNU_C ())
961 return N_SO_C2;
962 else if (lang_GNU_CXX ())
963 return N_SO_CC4;
964 else if (strcmp (language_string, "GNU F77") == 0)
965 return N_SO_FORTRAN5;
966 else if (lang_GNU_Fortran ())
967 return N_SO_FORTRAN907; /* CHECKME */
968 else if (strcmp (language_string, "GNU Objective-C") == 0)
969 return N_SO_OBJC50;
970 else if (strcmp (language_string, "GNU Objective-C++") == 0)
971 return N_SO_OBJCPLUS51;
972 else
973 return 0;
974
975}
976
977static bool
978is_fortran (void)
979{
980 unsigned int lang = get_lang_number ();
981
982 return (lang == N_SO_FORTRAN5) || (lang == N_SO_FORTRAN907);
983}
984
985/* At the beginning of compilation, start writing the symbol table.
986 Initialize `typevec' and output the standard data types of C. */
987
988static void
989dbxout_init (const char *input_file_name)
990{
991 char ltext_label_name[100];
992 bool used_ltext_label_name = false;
993 tree syms = lang_hooks.decls.getdecls ();
994 const char *mapped_name;
995
996 typevec_len = 100;
997 typevec = ggc_cleared_vec_alloc<typeinfo> (typevec_len);
998
999 /* stabstr_ob contains one string, which will be just fine with
1000 1-byte alignment. */
1001 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free)_obstack_begin ((&stabstr_ob), (0), (1), (xmalloc), (free
))
;
1002
1003 /* Convert Ltext into the appropriate format for local labels in case
1004 the system doesn't insert underscores in front of user generated
1005 labels. */
1006 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0)do { char *__p; (ltext_label_name)[0] = '*'; (ltext_label_name
)[1] = '.'; __p = stpcpy (&(ltext_label_name)[2], "Ltext"
); sprint_ul (__p, (unsigned long) (0)); } while (0)
;
1007
1008 /* Put the current working directory in an N_SO symbol. */
1009 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY0)
1010 {
1011 static const char *cwd;
1012
1013 if (!cwd)
1014 {
1015 cwd = get_src_pwd ();
1016 if (cwd[0] == '\0')
1017 cwd = "/";
1018 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1])(((cwd[strlen (cwd) - 1]) == '/') || (((cwd[strlen (cwd) - 1]
) == '\\') && (0)))
)
1019 cwd = concat (cwd, "/", NULLnullptr);
1020 cwd = remap_debug_filename (cwd);
1021 }
1022#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1023 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1024#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1025 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1026 dbxout_stab_value_label (ltext_label_name);
1027 used_ltext_label_name = true;
Value stored to 'used_ltext_label_name' is never read
1028#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1029 }
1030
1031 mapped_name = remap_debug_filename (input_file_name);
1032#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1033 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1034#else
1035 dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1036 dbxout_stab_value_label (ltext_label_name);
1037 used_ltext_label_name = true;
1038#endif
1039
1040 if (used_ltext_label_name)
1041 {
1042 switch_to_section (text_section);
1043 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1044 }
1045
1046 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1047 The string used is historical. */
1048#ifndef NO_DBX_GCC_MARKER
1049 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1050 dbxout_stab_value_zero ();
1051#endif
1052
1053 base_input_file = lastfile = input_file_name;
1054
1055 next_type_number = 1;
1056
1057#ifdef DBX_USE_BINCL
1058 current_file = XNEW (struct dbx_file)((struct dbx_file *) xmalloc (sizeof (struct dbx_file)));
1059 current_file->next = NULLnullptr;
1060 current_file->file_number = 0;
1061 current_file->next_type_number = 1;
1062 next_file_number = 1;
1063 current_file->prev = NULLnullptr;
1064 current_file->bincl_status = BINCL_NOT_REQUIRED;
1065 current_file->pending_bincl_name = NULLnullptr;
1066#endif
1067
1068 /* Get all permanent types that have typedef names, and output them
1069 all, except for those already output. Some language front ends
1070 put these declarations in the top-level scope; some do not;
1071 the latter are responsible for calling debug_hooks->type_decl from
1072 their record_builtin_type function. */
1073 dbxout_typedefs (syms);
1074
1075 if (preinit_symbols)
1076 {
1077 tree t;
1078 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1078, __FUNCTION__))->common.chain)
)
1079 dbxout_symbol (TREE_VALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1079, __FUNCTION__, (TREE_LIST)))->list.value)
, 0);
1080 preinit_symbols = 0;
1081 }
1082}
1083
1084/* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1085
1086static void
1087dbxout_typedefs (tree syms)
1088{
1089 for (; syms != NULL_TREE(tree) nullptr; syms = DECL_CHAIN (syms)(((contains_struct_check (((contains_struct_check ((syms), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1089, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1089, __FUNCTION__))->common.chain))
)
1090 {
1091 if (TREE_CODE (syms)((enum tree_code) (syms)->base.code) == TYPE_DECL)
1092 {
1093 tree type = TREE_TYPE (syms)((contains_struct_check ((syms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1093, __FUNCTION__))->typed.type)
;
1094 if (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1094, __FUNCTION__))->type_common.name)
1095 && TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1095, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL
1096 && COMPLETE_OR_VOID_TYPE_P (type)((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1096, __FUNCTION__))->type_common.size) != (tree) nullptr
) || (((enum tree_code) (type)->base.code) == VOID_TYPE))
1097 && ! TREE_ASM_WRITTEN (TYPE_NAME (type))((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1097, __FUNCTION__))->type_common.name))->base.asm_written_flag
)
)
1098 dbxout_symbol (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1098, __FUNCTION__))->type_common.name)
, 0);
1099 }
1100 }
1101}
1102
1103#ifdef DBX_USE_BINCL
1104/* Emit BINCL stab using given name. */
1105static void
1106emit_bincl_stab (const char *name)
1107{
1108 dbxout_begin_simple_stabs (name, N_BINCL);
1109 dbxout_stab_value_zero ();
1110}
1111
1112/* If there are pending bincls then it is time to emit all of them. */
1113
1114static inline void
1115emit_pending_bincls_if_required (void)
1116{
1117 if (pending_bincls)
1118 emit_pending_bincls ();
1119}
1120
1121/* Emit all pending bincls. */
1122
1123static void
1124emit_pending_bincls (void)
1125{
1126 struct dbx_file *f = current_file;
1127
1128 /* Find first pending bincl. */
1129 while (f->bincl_status == BINCL_PENDING)
1130 f = f->next;
1131
1132 /* Now emit all bincls. */
1133 f = f->prev;
1134
1135 while (f)
1136 {
1137 if (f->bincl_status == BINCL_PENDING)
1138 {
1139 emit_bincl_stab (f->pending_bincl_name);
1140
1141 /* Update file number and status. */
1142 f->file_number = next_file_number++;
1143 f->bincl_status = BINCL_PROCESSED;
1144 }
1145 if (f == current_file)
1146 break;
1147 f = f->prev;
1148 }
1149
1150 /* All pending bincls have been emitted. */
1151 pending_bincls = 0;
1152}
1153
1154#else
1155
1156static inline void
1157emit_pending_bincls_if_required (void) {}
1158#endif
1159
1160/* Change to reading from a new source file. Generate a N_BINCL stab. */
1161
1162static void
1163dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
1164 const char *filename ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1165{
1166#ifdef DBX_USE_BINCL
1167 struct dbx_file *n = XNEW (struct dbx_file)((struct dbx_file *) xmalloc (sizeof (struct dbx_file)));
1168
1169 n->next = current_file;
1170 n->next_type_number = 1;
1171 /* Do not assign file number now.
1172 Delay it until we actually emit BINCL. */
1173 n->file_number = 0;
1174 n->prev = NULLnullptr;
1175 current_file->prev = n;
1176 n->bincl_status = BINCL_PENDING;
1177 n->pending_bincl_name = remap_debug_filename (filename);
1178 pending_bincls = 1;
1179 current_file = n;
1180#endif
1181}
1182
1183/* Revert to reading a previous source file. Generate a N_EINCL stab. */
1184
1185static void
1186dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1187{
1188#ifdef DBX_USE_BINCL
1189 /* Emit EINCL stab only if BINCL is not pending. */
1190 if (current_file->bincl_status == BINCL_PROCESSED)
1191 {
1192 dbxout_begin_stabn (N_EINCL);
1193 dbxout_stab_value_zero ();
1194 }
1195 current_file->bincl_status = BINCL_NOT_REQUIRED;
1196 current_file = current_file->next;
1197#endif
1198}
1199
1200/* Handle a few odd cases that occur when trying to make PCH files work. */
1201
1202static void
1203dbxout_handle_pch (unsigned at_end)
1204{
1205 if (! at_end)
1206 {
1207 /* When using the PCH, this file will be included, so we need to output
1208 a BINCL. */
1209 dbxout_start_source_file (0, lastfile);
1210
1211 /* The base file when using the PCH won't be the same as
1212 the base file when it's being generated. */
1213 lastfile = NULLnullptr;
1214 }
1215 else
1216 {
1217 /* ... and an EINCL. */
1218 dbxout_end_source_file (0);
1219
1220 /* Deal with cases where 'lastfile' was never actually changed. */
1221 lastfile_is_base = lastfile == NULLnullptr;
1222 }
1223}
1224
1225#if defined (DBX_DEBUGGING_INFO1)
1226
1227static bool dbxout_block (tree, int, tree, int);
1228
1229/* Output debugging info to FILE to switch to sourcefile FILENAME. */
1230
1231static void
1232dbxout_source_file (const char *filename)
1233{
1234 if (lastfile == 0 && lastfile_is_base)
1235 {
1236 lastfile = base_input_file;
1237 lastfile_is_base = 0;
1238 }
1239
1240 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1241 {
1242 /* Don't change section amid function. */
1243 if (current_function_decl == NULL_TREE(tree) nullptr)
1244 switch_to_section (text_section);
1245
1246 dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1247 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1248 lastfile = filename;
1249 }
1250}
1251
1252/* Output N_BNSYM, line number symbol entry, and local symbol at
1253 function scope */
1254
1255static void
1256dbxout_begin_prologue (unsigned int lineno,
1257 unsigned int column ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
1258 const char *filename)
1259{
1260 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
1261 && !NO_DBX_FUNCTION_END0
1262 && !NO_DBX_BNSYM_ENSYM0
1263 && !flag_debug_only_used_symbolsglobal_options.x_flag_debug_only_used_symbols)
1264 dbxout_stabd (N_BNSYM, 0);
1265
1266 /* pre-increment the scope counter */
1267 scope_labelno++;
1268
1269 dbxout_source_line (lineno, 0, filename, 0, true);
1270 /* Output function begin block at function scope, referenced
1271 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1272 emit_pending_bincls_if_required ();
1273 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1274}
1275
1276/* Output a line number symbol entry for source file FILENAME and line
1277 number LINENO. */
1278
1279static void
1280dbxout_source_line (unsigned int lineno, unsigned int column ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
1281 const char *filename, int discriminator ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
1282 bool is_stmt ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1283{
1284 dbxout_source_file (filename);
1285
1286#ifdef DBX_OUTPUT_SOURCE_LINE
1287 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1288#else
1289 if (DBX_LINES_FUNCTION_RELATIVE1)
1290 {
1291 char begin_label[20];
1292 dbxout_begin_stabn_sline (lineno);
1293 /* Reference current function start using LFBB. */
1294 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno)do { char *__p; (begin_label)[0] = '*'; (begin_label)[1] = '.'
; __p = stpcpy (&(begin_label)[2], "LFBB"); sprint_ul (__p
, (unsigned long) (scope_labelno)); } while (0)
;
1295 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1296 begin_label);
1297 }
1298 else
1299 dbxout_stabd (N_SLINE, lineno);
1300#endif
1301 lastlineno = lineno;
1302}
1303
1304/* Unfortunately, at least when emitting relative addresses, STABS
1305 has no way to express multiple partitions. Represent a function
1306 as two functions in this case. */
1307
1308static void
1309dbxout_switch_text_section (void)
1310{
1311 /* The N_FUN tag at the end of the function is a GNU extension,
1312 which may be undesirable, and is unnecessary if we do not have
1313 named sections. */
1314 in_cold_section_p = !in_cold_section_p;
1315 switch_to_section (current_function_section ());
1316 dbxout_block (DECL_INITIAL (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1316, __FUNCTION__))->decl_common.initial)
, 0,
1317 DECL_ARGUMENTS (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1317, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
, -1);
1318 dbxout_function_end (current_function_decl);
1319 in_cold_section_p = !in_cold_section_p;
1320
1321 switch_to_section (current_function_section ());
1322
1323 tree context = decl_function_context (current_function_decl);
1324 extern tree cold_function_name;
1325
1326 dbxout_begin_complex_stabs ();
1327 stabstr_I (cold_function_name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((cold_function_name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1327, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((cold_function_name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1327, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
1328 stabstr_S (":f")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (":f")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ":f", __len); __o->next_free += __len
; (void) 0; })
;
1329
1330 tree type = TREE_TYPE (current_function_decl)((contains_struct_check ((current_function_decl), (TS_TYPED),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1330, __FUNCTION__))->typed.type)
;
1331 if (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1331, __FUNCTION__))->typed.type)
)
1332 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1332, __FUNCTION__))->typed.type)
, 0);
1333 else
1334 dbxout_type (void_type_nodeglobal_trees[TI_VOID_TYPE], 0);
1335
1336 if (context != 0)
1337 {
1338 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
1339 stabstr_I (cold_function_name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((cold_function_name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1339, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((cold_function_name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1339, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
1340 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
1341 stabstr_I (DECL_NAME (context))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((((contains_struct_check ((context), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1341, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1341, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((((contains_struct_check ((context
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1341, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1341, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
1342 }
1343
1344 dbxout_finish_complex_stabs (current_function_decl, N_FUN, 0,
1345 crtl(&x_rtl)->subsections.cold_section_label, 0);
1346
1347 /* pre-increment the scope counter */
1348 scope_labelno++;
1349
1350 dbxout_source_line (lastlineno, 0, lastfile, 0, true);
1351 /* Output function begin block at function scope, referenced
1352 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1353 emit_pending_bincls_if_required ();
1354 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1355}
1356
1357/* Describe the beginning of an internal block within a function. */
1358
1359static void
1360dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED__attribute__ ((__unused__)), unsigned int n)
1361{
1362 emit_pending_bincls_if_required ();
1363 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1364}
1365
1366/* Describe the end line-number of an internal block within a function. */
1367
1368static void
1369dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED__attribute__ ((__unused__)), unsigned int n)
1370{
1371 emit_pending_bincls_if_required ();
1372 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1373}
1374
1375/* Output dbx data for a function definition.
1376 This includes a definition of the function name itself (a symbol),
1377 definitions of the parameters (locating them in the parameter list)
1378 and then output the block that makes up the function's body
1379 (including all the auto variables of the function). */
1380
1381static void
1382dbxout_function_decl (tree decl)
1383{
1384 emit_pending_bincls_if_required ();
1385#ifndef DBX_FUNCTION_FIRST
1386 dbxout_begin_function (decl);
1387#endif
1388 dbxout_block (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1388, __FUNCTION__))->decl_common.initial)
, 0, DECL_ARGUMENTS (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1388, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
, -1);
1389 dbxout_function_end (decl);
1390}
1391
1392#endif /* DBX_DEBUGGING_INFO */
1393
1394static void
1395dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1396{
1397 /* NYI for non-dwarf. */
1398}
1399
1400/* Debug information for a global DECL. Called from toplev.c after
1401 compilation proper has finished. */
1402static void
1403dbxout_late_global_decl (tree decl)
1404{
1405 if (VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL) && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1405, __FUNCTION__))->decl_common.decl_flag_1)
)
1406 {
1407 int saved_tree_used = TREE_USED (decl)((decl)->base.used_flag);
1408 TREE_USED (decl)((decl)->base.used_flag) = 1;
1409 dbxout_symbol (decl, 0);
1410 TREE_USED (decl)((decl)->base.used_flag) = saved_tree_used;
1411 }
1412}
1413
1414/* This is just a function-type adapter; dbxout_symbol does exactly
1415 what we want but returns an int. */
1416static void
1417dbxout_type_decl (tree decl, int local)
1418{
1419 dbxout_symbol (decl, local);
1420}
1421
1422/* At the end of compilation, finish writing the symbol table.
1423 The default is to call debug_free_queue but do nothing else. */
1424
1425static void
1426dbxout_finish (const char *filename ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1427{
1428#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1429 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1430#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1431 {
1432 switch_to_section (text_section);
1433 dbxout_begin_empty_stabs (N_SO);
1434 dbxout_stab_value_internal_label ("Letext", 0);
1435 }
1436#endif
1437 debug_free_queue ();
1438}
1439
1440/* Output the index of a type. */
1441
1442static void
1443dbxout_type_index (tree type)
1444{
1445#ifndef DBX_USE_BINCL
1446 stabstr_D (TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1446, __FUNCTION__))->type_common.symtab.address)
);
1447#else
1448 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1448, __FUNCTION__))->type_common.symtab.address)
];
1449 stabstr_C ('(')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('('))); })
;
1450 stabstr_D (t->file_number);
1451 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
1452 stabstr_D (t->type_number);
1453 stabstr_C (')')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (')'))); })
;
1454#endif
1455}
1456
1457
1458/* Generate the symbols for any queued up type symbols we encountered
1459 while generating the type info for some originally used symbol.
1460 This might generate additional entries in the queue. Only when
1461 the nesting depth goes to 0 is this routine called. */
1462
1463static void
1464debug_flush_symbol_queue (void)
1465{
1466 int i;
1467
1468 /* Make sure that additionally queued items are not flushed
1469 prematurely. */
1470
1471 ++debug_nesting;
1472
1473 for (i = 0; i < symbol_queue_index; ++i)
1474 {
1475 /* If we pushed queued symbols then such symbols must be
1476 output no matter what anyone else says. Specifically,
1477 we need to make sure dbxout_symbol() thinks the symbol was
1478 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1479 which may be set for outside reasons. */
1480 int saved_tree_used = TREE_USED (symbol_queue[i])((symbol_queue[i])->base.used_flag);
1481 int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i])((tree_check ((symbol_queue[i]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1481, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
;
1482 TREE_USED (symbol_queue[i])((symbol_queue[i])->base.used_flag) = 1;
1483 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i])((tree_check ((symbol_queue[i]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1483, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
= 0;
1484
1485#ifdef DBX_DEBUGGING_INFO1
1486 dbxout_symbol (symbol_queue[i], 0);
1487#endif
1488
1489 TREE_USED (symbol_queue[i])((symbol_queue[i])->base.used_flag) = saved_tree_used;
1490 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i])((tree_check ((symbol_queue[i]), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1490, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
= saved_suppress_debug;
1491 }
1492
1493 symbol_queue_index = 0;
1494 --debug_nesting;
1495}
1496
1497/* Queue a type symbol needed as part of the definition of a decl
1498 symbol. These symbols are generated when debug_flush_symbol_queue()
1499 is called. */
1500
1501static void
1502debug_queue_symbol (tree decl)
1503{
1504 if (symbol_queue_index >= symbol_queue_size)
1505 {
1506 symbol_queue_size += 10;
1507 symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size)((tree *) xrealloc ((void *) (symbol_queue), sizeof (tree) * (
symbol_queue_size)))
;
1508 }
1509
1510 symbol_queue[symbol_queue_index++] = decl;
1511}
1512
1513/* Free symbol queue. */
1514static void
1515debug_free_queue (void)
1516{
1517 if (symbol_queue)
1518 {
1519 free (symbol_queue);
1520 symbol_queue = NULLnullptr;
1521 symbol_queue_size = 0;
1522 }
1523}
1524
1525/* Used in several places: evaluates to '0' for a private decl,
1526 '1' for a protected decl, '2' for a public decl. */
1527#define DECL_ACCESSIBILITY_CHAR(DECL)(((DECL)->base.private_flag) ? '0' : ((DECL)->base.protected_flag
) ? '1' : '2')
\
1528(TREE_PRIVATE (DECL)((DECL)->base.private_flag) ? '0' : TREE_PROTECTED (DECL)((DECL)->base.protected_flag) ? '1' : '2')
1529
1530/* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1531 This must be a separate function because anonymous unions require
1532 recursive calls. */
1533
1534static void
1535dbxout_type_fields (tree type)
1536{
1537 tree tem;
1538
1539 /* Output the name, type, position (in bits), size (in bits) of each
1540 field that we can support. */
1541 for (tem = TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1541, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
; tem; tem = DECL_CHAIN (tem)(((contains_struct_check (((contains_struct_check ((tem), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1541, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1541, __FUNCTION__))->common.chain))
)
1542 {
1543 /* If one of the nodes is an error_mark or its type is then
1544 return early. */
1545 if (error_operand_p (tem)((tem) == global_trees[TI_ERROR_MARK] || ((tem) && ((
contains_struct_check (((tem)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1545, __FUNCTION__))->typed.type) == global_trees[TI_ERROR_MARK
]))
)
1546 return;
1547
1548 /* Omit here local type decls until we know how to support them. */
1549 if (TREE_CODE (tem)((enum tree_code) (tem)->base.code) == TYPE_DECL
1550 || TREE_CODE (tem)((enum tree_code) (tem)->base.code) == TEMPLATE_DECL
1551 /* Member functions emitted after fields. */
1552 || TREE_CODE (tem)((enum tree_code) (tem)->base.code) == FUNCTION_DECL
1553 /* Omit here the nameless fields that are used to skip bits. */
1554 || DECL_IGNORED_P (tem)((contains_struct_check ((tem), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1554, __FUNCTION__))->decl_common.ignored_flag)
1555 /* Omit fields whose position or size are variable or too large to
1556 represent. */
1557 || (TREE_CODE (tem)((enum tree_code) (tem)->base.code) == FIELD_DECL
1558 && (! tree_fits_shwi_p (bit_position (tem))
1559 || ! DECL_SIZE (tem)((contains_struct_check ((tem), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1559, __FUNCTION__))->decl_common.size)
1560 || ! tree_fits_uhwi_p (DECL_SIZE (tem)((contains_struct_check ((tem), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1560, __FUNCTION__))->decl_common.size)
))))
1561 continue;
1562
1563 else if (TREE_CODE (tem)((enum tree_code) (tem)->base.code) != CONST_DECL)
1564 {
1565 /* Continue the line if necessary,
1566 but not before the first field. */
1567 if (tem != TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1567, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
)
1568 CONTINstabstr_continue ();
1569
1570 if (DECL_NAME (tem)((contains_struct_check ((tem), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1570, __FUNCTION__))->decl_minimal.name)
)
1571 stabstr_I (DECL_NAME (tem))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((((contains_struct_check ((tem), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1571, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1571, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((((contains_struct_check ((tem), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1571, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1571, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
1572 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
1573
1574 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
1575 && (TREE_PRIVATE (tem)((tem)->base.private_flag) || TREE_PROTECTED (tem)((tem)->base.protected_flag)
1576 || TREE_CODE (tem)((enum tree_code) (tem)->base.code) != FIELD_DECL))
1577 {
1578 stabstr_C ('/')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('/'))); })
;
1579 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem))__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ((((tem)->base
.private_flag) ? '0' : ((tem)->base.protected_flag) ? '1' :
'2')))); })
;
1580 }
1581
1582 dbxout_type ((TREE_CODE (tem)((enum tree_code) (tem)->base.code) == FIELD_DECL
1583 && DECL_BIT_FIELD_TYPE (tem)((tree_check ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1583, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
)
1584 ? DECL_BIT_FIELD_TYPE (tem)((tree_check ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1584, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_field_type
)
: TREE_TYPE (tem)((contains_struct_check ((tem), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1584, __FUNCTION__))->typed.type)
, 0);
1585
1586 if (VAR_P (tem)(((enum tree_code) (tem)->base.code) == VAR_DECL))
1587 {
1588 if (TREE_STATIC (tem)((tem)->base.static_flag) && use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
1589 {
1590 tree name = DECL_ASSEMBLER_NAME (tem)decl_assembler_name (tem);
1591
1592 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
1593 stabstr_I (name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1593, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1593, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
1594 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1595 }
1596 else
1597 /* If TEM is non-static, GDB won't understand it. */
1598 stabstr_S (",0,0;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (",0,0;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ",0,0;", __len); __o->next_free += __len
; (void) 0; })
;
1599 }
1600 else
1601 {
1602 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
1603 stabstr_D (int_bit_position (tem));
1604 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
1605 stabstr_D (tree_to_uhwi (DECL_SIZE (tem)((contains_struct_check ((tem), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1605, __FUNCTION__))->decl_common.size)
));
1606 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1607 }
1608 }
1609 }
1610}
1611
1612/* Subroutine of `dbxout_type_methods'. Output debug info about the
1613 method described DECL. */
1614
1615static void
1616dbxout_type_method_1 (tree decl)
1617{
1618 char c1 = 'A', c2;
1619
1620 if (TREE_CODE (TREE_TYPE (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1620, __FUNCTION__))->typed.type))->base.code)
== FUNCTION_TYPE)
1621 c2 = '?';
1622 else /* it's a METHOD_TYPE. */
1623 {
1624 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))((tree_check ((((tree_check2 ((((contains_struct_check ((decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1624, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1624, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1624, __FUNCTION__, (TREE_LIST)))->list.value)
;
1625 /* A for normal functions.
1626 B for `const' member functions.
1627 C for `volatile' member functions.
1628 D for `const volatile' member functions. */
1629 if (TYPE_READONLY (TREE_TYPE (firstarg))((tree_class_check ((((contains_struct_check ((firstarg), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1629, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1629, __FUNCTION__))->base.readonly_flag)
)
1630 c1 += 1;
1631 if (TYPE_VOLATILE (TREE_TYPE (firstarg))((tree_class_check ((((contains_struct_check ((firstarg), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1631, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1631, __FUNCTION__))->base.volatile_flag)
)
1632 c1 += 2;
1633
1634 if (DECL_VINDEX (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1634, __FUNCTION__, (FUNCTION_DECL)))->function_decl.vindex
)
)
1635 c2 = '*';
1636 else
1637 c2 = '.';
1638 }
1639
1640 /* ??? Output the mangled name, which contains an encoding of the
1641 method's type signature. May not be necessary anymore. */
1642 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
1643 stabstr_I (DECL_ASSEMBLER_NAME (decl))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((decl_assembler_name (decl)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1643, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((decl_assembler_name (decl)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1643, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
1644 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1645 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl))__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ((((decl)->
base.private_flag) ? '0' : ((decl)->base.protected_flag) ?
'1' : '2')))); })
;
1646 stabstr_C (c1)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (c1))); })
;
1647 stabstr_C (c2)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (c2))); })
;
1648
1649 if (DECL_VINDEX (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1649, __FUNCTION__, (FUNCTION_DECL)))->function_decl.vindex
)
&& tree_fits_shwi_p (DECL_VINDEX (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1649, __FUNCTION__, (FUNCTION_DECL)))->function_decl.vindex
)
))
1650 {
1651 stabstr_D (tree_to_shwi (DECL_VINDEX (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1651, __FUNCTION__, (FUNCTION_DECL)))->function_decl.vindex
)
));
1652 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1653 dbxout_type (DECL_CONTEXT (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1653, __FUNCTION__))->decl_minimal.context)
, 0);
1654 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1655 }
1656}
1657
1658/* Subroutine of `dbxout_type'. Output debug info about the member
1659 functions defined in TYPE. */
1660
1661static void
1662dbxout_type_methods (tree type)
1663{
1664 for (tree fndecl = TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1664, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
; fndecl;)
1665 {
1666 int need_prefix = 1;
1667
1668 /* Group together all the methods for the same operation.
1669 These differ in the types of the arguments. */
1670 for (tree last = NULL_TREE(tree) nullptr;
1671 fndecl && (last == NULL_TREE(tree) nullptr || DECL_NAME (fndecl)((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1671, __FUNCTION__))->decl_minimal.name)
== DECL_NAME (last)((contains_struct_check ((last), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1671, __FUNCTION__))->decl_minimal.name)
);
1672 fndecl = DECL_CHAIN (fndecl)(((contains_struct_check (((contains_struct_check ((fndecl), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1672, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1672, __FUNCTION__))->common.chain))
)
1673 /* Output the name of the field (after overloading), as
1674 well as the name of the field before overloading, along
1675 with its parameter list */
1676 {
1677 /* Skip non-functions. */
1678 if (TREE_CODE (fndecl)((enum tree_code) (fndecl)->base.code) != FUNCTION_DECL)
1679 continue;
1680
1681 /* Also ignore abstract methods; those are only interesting to
1682 the DWARF backends. */
1683 if (DECL_IGNORED_P (fndecl)((contains_struct_check ((fndecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1683, __FUNCTION__))->decl_common.ignored_flag)
|| DECL_ABSTRACT_P (fndecl)((contains_struct_check ((fndecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1683, __FUNCTION__))->decl_common.abstract_flag)
)
1684 continue;
1685
1686 CONTINstabstr_continue ();
1687
1688 last = fndecl;
1689
1690 /* Redundantly output the plain name, since that's what gdb
1691 expects. */
1692 if (need_prefix)
1693 {
1694 stabstr_I (DECL_NAME (fndecl))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((((contains_struct_check ((fndecl), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1694, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1694, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((((contains_struct_check ((fndecl
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1694, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1694, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
1695 stabstr_S ("::")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("::")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "::", __len); __o->next_free += __len
; (void) 0; })
;
1696 need_prefix = 0;
1697 }
1698
1699 dbxout_type (TREE_TYPE (fndecl)((contains_struct_check ((fndecl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1699, __FUNCTION__))->typed.type)
, 0);
1700 dbxout_type_method_1 (fndecl);
1701 }
1702 if (!need_prefix)
1703 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1704 }
1705}
1706
1707/* Emit a "range" type specification, which has the form:
1708 "r<index type>;<lower bound>;<upper bound>;".
1709 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1710
1711static void
1712dbxout_range_type (tree type, tree low, tree high)
1713{
1714 stabstr_C ('r')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('r'))); })
;
1715 if (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1715, __FUNCTION__))->typed.type)
)
1716 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1716, __FUNCTION__))->typed.type)
, 0);
1717 else if (TREE_CODE (type)((enum tree_code) (type)->base.code) != INTEGER_TYPE)
1718 dbxout_type (type, 0);
1719 else
1720 {
1721 /* Traditionally, we made sure 'int' was type 1, and builtin types
1722 were defined to be sub-ranges of int. Unfortunately, this
1723 does not allow us to distinguish true sub-ranges from integer
1724 types. So, instead we define integer (non-sub-range) types as
1725 sub-ranges of themselves. This matters for Chill. If this isn't
1726 a subrange type, then we want to define it in terms of itself.
1727 However, in C, this may be an anonymous integer type, and we don't
1728 want to emit debug info referring to it. Just calling
1729 dbxout_type_index won't work anyways, because the type hasn't been
1730 defined yet. We make this work for both cases by checked to see
1731 whether this is a defined type, referring to it if it is, and using
1732 'int' otherwise. */
1733 if (TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1733, __FUNCTION__))->type_common.symtab.address)
!= 0)
1734 dbxout_type_index (type);
1735 else
1736 dbxout_type_index (integer_type_nodeinteger_types[itk_int]);
1737 }
1738
1739 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1740 if (low && tree_fits_shwi_p (low))
1741 {
1742 if (print_int_cst_bounds_in_octal_p (type, low, high))
1743 stabstr_O (low);
1744 else
1745 stabstr_D (tree_to_shwi (low));
1746 }
1747 else
1748 stabstr_C ('0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('0'))); })
;
1749
1750 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1751 if (high && tree_fits_shwi_p (high))
1752 {
1753 if (print_int_cst_bounds_in_octal_p (type, low, high))
1754 stabstr_O (high);
1755 else
1756 stabstr_D (tree_to_shwi (high));
1757 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
1758 }
1759 else
1760 stabstr_S ("-1;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("-1;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "-1;", __len); __o->next_free += __len
; (void) 0; })
;
1761}
1762
1763
1764/* Output a reference to a type. If the type has not yet been
1765 described in the dbx output, output its definition now.
1766 For a type already defined, just refer to its definition
1767 using the type number.
1768
1769 If FULL is nonzero, and the type has been described only with
1770 a forward-reference, output the definition now.
1771 If FULL is zero in this case, just refer to the forward-reference
1772 using the number previously allocated. */
1773
1774static void
1775dbxout_type (tree type, int full)
1776{
1777 static int anonymous_type_number = 0;
1778 tree tem, main_variant, low, high;
1779
1780 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == INTEGER_TYPE)
1781 {
1782 if (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1782, __FUNCTION__))->typed.type)
== 0)
1783 {
1784 low = TYPE_MIN_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1784, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
;
1785 high = TYPE_MAX_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1785, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
1786 }
1787
1788 else if (subrange_type_for_debug_p (type, &low, &high))
1789 ;
1790
1791 /* If this is a subtype that should not be emitted as a subrange type,
1792 use the base type. */
1793 else
1794 {
1795 type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1795, __FUNCTION__))->typed.type)
;
1796 low = TYPE_MIN_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1796, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
;
1797 high = TYPE_MAX_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1797, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
1798 }
1799 }
1800
1801 /* If there was an input error and we don't really have a type,
1802 avoid crashing and write something that is at least valid
1803 by assuming `int'. */
1804 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1805 type = integer_type_nodeinteger_types[itk_int];
1806 else
1807 {
1808 if (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1808, __FUNCTION__))->type_common.name)
1809 && TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1809, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL
1810 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type))((tree_check ((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1810, __FUNCTION__))->type_common.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1810, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
)
1811 full = 0;
1812 }
1813
1814 /* Try to find the "main variant" with the same name. */
1815 if (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1815, __FUNCTION__))->type_common.name)
&& TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1815, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL
1816 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))((tree_check ((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1816, __FUNCTION__))->type_common.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1816, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
)
)
1817 main_variant = TREE_TYPE (TYPE_NAME (type))((contains_struct_check ((((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1817, __FUNCTION__))->type_common.name)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1817, __FUNCTION__))->typed.type)
;
1818 else
1819 main_variant = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1819, __FUNCTION__))->type_common.main_variant)
;
1820
1821 /* If we are not using extensions, stabs does not distinguish const and
1822 volatile, so there is no need to make them separate types. */
1823 if (!use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
1824 type = main_variant;
1825
1826 if (TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1826, __FUNCTION__))->type_common.symtab.address)
== 0)
1827 {
1828 /* Type has no dbx number assigned. Assign next available number. */
1829 TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1829, __FUNCTION__))->type_common.symtab.address)
= next_type_number++;
1830
1831 /* Make sure type vector is long enough to record about this type. */
1832
1833 if (next_type_number == typevec_len)
1834 {
1835 typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2)((struct typeinfo *) ggc_realloc ((typevec), (typevec_len * 2
) * sizeof (struct typeinfo) ))
;
1836 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1837 typevec_len *= 2;
1838 }
1839
1840#ifdef DBX_USE_BINCL
1841 emit_pending_bincls_if_required ();
1842 typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1842, __FUNCTION__))->type_common.symtab.address)
].file_number
1843 = current_file->file_number;
1844 typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1844, __FUNCTION__))->type_common.symtab.address)
].type_number
1845 = current_file->next_type_number++;
1846#endif
1847 }
1848
1849 if (flag_debug_only_used_symbolsglobal_options.x_flag_debug_only_used_symbols)
1850 {
1851 if ((TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE
1852 || TREE_CODE (type)((enum tree_code) (type)->base.code) == UNION_TYPE
1853 || TREE_CODE (type)((enum tree_code) (type)->base.code) == QUAL_UNION_TYPE
1854 || TREE_CODE (type)((enum tree_code) (type)->base.code) == ENUMERAL_TYPE)
1855 && TYPE_STUB_DECL (type)(((contains_struct_check (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1855, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1855, __FUNCTION__))->common.chain))
1856 && DECL_P (TYPE_STUB_DECL (type))(tree_code_type[(int) (((enum tree_code) ((((contains_struct_check
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1856, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1856, __FUNCTION__))->common.chain)))->base.code))] ==
tcc_declaration)
1857 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type))((contains_struct_check (((((contains_struct_check (((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1857, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1857, __FUNCTION__))->common.chain))), (TS_DECL_COMMON),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1857, __FUNCTION__))->decl_common.ignored_flag)
)
1858 debug_queue_symbol (TYPE_STUB_DECL (type)(((contains_struct_check (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1858, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1858, __FUNCTION__))->common.chain))
);
1859 else if (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1859, __FUNCTION__))->type_common.name)
1860 && TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1860, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL)
1861 debug_queue_symbol (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1861, __FUNCTION__))->type_common.name)
);
1862 }
1863
1864 /* Output the number of this type, to refer to it. */
1865 dbxout_type_index (type);
1866
1867#ifdef DBX_TYPE_DEFINED
1868 if (DBX_TYPE_DEFINED (type))
1869 return;
1870#endif
1871
1872 /* If this type's definition has been output or is now being output,
1873 that is all. */
1874
1875 switch (typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1875, __FUNCTION__))->type_common.symtab.address)
].status)
1876 {
1877 case TYPE_UNSEEN:
1878 break;
1879 case TYPE_XREF:
1880 /* If we have already had a cross reference,
1881 and either that's all we want or that's the best we could do,
1882 don't repeat the cross reference.
1883 Sun dbx crashes if we do. */
1884 if (! full || !COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1884, __FUNCTION__))->type_common.size) != (tree) nullptr
)
1885 /* No way in DBX fmt to describe a variable size. */
1886 || ! tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1886, __FUNCTION__))->type_common.size)
))
1887 return;
1888 break;
1889 case TYPE_DEFINED:
1890 return;
1891 }
1892
1893#ifdef DBX_NO_XREFS
1894 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1895 leave the type-number completely undefined rather than output
1896 a cross-reference. If we have already used GNU debug info extensions,
1897 then it is OK to output a cross reference. This is necessary to get
1898 proper C++ debug output. */
1899 if ((TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE || TREE_CODE (type)((enum tree_code) (type)->base.code) == UNION_TYPE
1900 || TREE_CODE (type)((enum tree_code) (type)->base.code) == QUAL_UNION_TYPE
1901 || TREE_CODE (type)((enum tree_code) (type)->base.code) == ENUMERAL_TYPE)
1902 && ! use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
1903 /* We must use the same test here as we use twice below when deciding
1904 whether to emit a cross-reference. */
1905 if ((TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1905, __FUNCTION__))->type_common.name)
!= 0
1906 && ! (TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1906, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL
1907 && DECL_IGNORED_P (TYPE_NAME (type))((contains_struct_check ((((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1907, __FUNCTION__))->type_common.name)), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1907, __FUNCTION__))->decl_common.ignored_flag)
)
1908 && !full)
1909 || !COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1909, __FUNCTION__))->type_common.size) != (tree) nullptr
)
1910 /* No way in DBX fmt to describe a variable size. */
1911 || ! tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1911, __FUNCTION__))->type_common.size)
))
1912 {
1913 typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1913, __FUNCTION__))->type_common.symtab.address)
].status = TYPE_XREF;
1914 return;
1915 }
1916#endif
1917
1918 /* Output a definition now. */
1919 stabstr_C ('=')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('='))); })
;
1920
1921 /* Mark it as defined, so that if it is self-referent
1922 we will not get into an infinite recursion of definitions. */
1923
1924 typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1924, __FUNCTION__))->type_common.symtab.address)
].status = TYPE_DEFINED;
1925
1926 /* If this type is a variant of some other, hand off. Types with
1927 different names are usefully distinguished. We only distinguish
1928 cv-qualified types if we're using extensions. */
1929 if (TYPE_READONLY (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1929, __FUNCTION__))->base.readonly_flag)
> TYPE_READONLY (main_variant)((tree_class_check ((main_variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1929, __FUNCTION__))->base.readonly_flag)
)
1930 {
1931 stabstr_C ('k')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('k'))); })
;
1932 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type))build_qualified_type ((type), ((0) ? TYPE_QUAL_CONST : 0) | (
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1932, __FUNCTION__))->base.volatile_flag)) ? TYPE_QUAL_VOLATILE
: 0))
, 0);
1933 return;
1934 }
1935 else if (TYPE_VOLATILE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1935, __FUNCTION__))->base.volatile_flag)
> TYPE_VOLATILE (main_variant)((tree_class_check ((main_variant), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1935, __FUNCTION__))->base.volatile_flag)
)
1936 {
1937 stabstr_C ('B')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('B'))); })
;
1938 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0)build_qualified_type ((type), ((((tree_class_check ((type), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1938, __FUNCTION__))->base.readonly_flag)) ? TYPE_QUAL_CONST
: 0) | ((0) ? TYPE_QUAL_VOLATILE : 0))
, 0);
1939 return;
1940 }
1941 else if (main_variant != TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1941, __FUNCTION__))->type_common.main_variant)
)
1942 {
1943 if (flag_debug_only_used_symbolsglobal_options.x_flag_debug_only_used_symbols)
1944 {
1945 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type))((tree_check ((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1945, __FUNCTION__))->type_common.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1945, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
)
;
1946
1947 if ((TREE_CODE (orig_type)((enum tree_code) (orig_type)->base.code) == RECORD_TYPE
1948 || TREE_CODE (orig_type)((enum tree_code) (orig_type)->base.code) == UNION_TYPE
1949 || TREE_CODE (orig_type)((enum tree_code) (orig_type)->base.code) == QUAL_UNION_TYPE
1950 || TREE_CODE (orig_type)((enum tree_code) (orig_type)->base.code) == ENUMERAL_TYPE)
1951 && TYPE_STUB_DECL (orig_type)(((contains_struct_check (((tree_class_check ((orig_type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1951, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1951, __FUNCTION__))->common.chain))
1952 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type))((contains_struct_check (((((contains_struct_check (((tree_class_check
((orig_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1952, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1952, __FUNCTION__))->common.chain))), (TS_DECL_COMMON),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1952, __FUNCTION__))->decl_common.ignored_flag)
)
1953 debug_queue_symbol (TYPE_STUB_DECL (orig_type)(((contains_struct_check (((tree_class_check ((orig_type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1953, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1953, __FUNCTION__))->common.chain))
);
1954 }
1955 /* 'type' is a typedef; output the type it refers to. */
1956 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type))((tree_check ((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1956, __FUNCTION__))->type_common.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1956, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
)
, 0);
1957 return;
1958 }
1959 /* else continue. */
1960
1961 switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
1962 {
1963 case VOID_TYPE:
1964 case NULLPTR_TYPE:
1965 case LANG_TYPE:
1966 case OPAQUE_TYPE:
1967 /* For a void type, just define it as itself; i.e., "5=5".
1968 This makes us consider it defined
1969 without saying what it is. The debugger will make it
1970 a void type when the reference is seen, and nothing will
1971 ever override that default. */
1972 dbxout_type_index (type);
1973 break;
1974
1975 case INTEGER_TYPE:
1976 if (type == char_type_nodeinteger_types[itk_char] && ! TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1976, __FUNCTION__))->base.u.bits.unsigned_flag)
)
1977 {
1978 /* Output the type `char' as a subrange of itself!
1979 I don't understand this definition, just copied it
1980 from the output of pcc.
1981 This used to use `r2' explicitly and we used to
1982 take care to make sure that `char' was type number 2. */
1983 stabstr_C ('r')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('r'))); })
;
1984 dbxout_type_index (type);
1985 stabstr_S (";0;127;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";0;127;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";0;127;", __len); __o->next_free += __len
; (void) 0; })
;
1986 }
1987
1988 /* If this is a subtype of another integer type, always prefer to
1989 write it as a subtype. */
1990 else if (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1990, __FUNCTION__))->typed.type)
!= 0
1991 && TREE_CODE (TREE_TYPE (type))((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1991, __FUNCTION__))->typed.type))->base.code)
== INTEGER_TYPE)
1992 {
1993 /* If the size is non-standard, say what it is if we can use
1994 GDB extensions. */
1995
1996 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
1997 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1997, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (integer_type_node)((tree_class_check ((integer_types[itk_int]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 1997, __FUNCTION__))->type_common.precision)
)
1998 {
1999 stabstr_S ("@s")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("@s")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "@s", __len); __o->next_free += __len
; (void) 0; })
;
2000 stabstr_D (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2000, __FUNCTION__))->type_common.precision)
);
2001 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2002 }
2003
2004 dbxout_range_type (type, low, high);
2005 }
2006
2007 else
2008 {
2009 /* If the size is non-standard, say what it is if we can use
2010 GDB extensions. */
2011
2012 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
2013 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2013, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (integer_type_node)((tree_class_check ((integer_types[itk_int]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2013, __FUNCTION__))->type_common.precision)
)
2014 {
2015 stabstr_S ("@s")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("@s")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "@s", __len); __o->next_free += __len
; (void) 0; })
;
2016 stabstr_D (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2016, __FUNCTION__))->type_common.precision)
);
2017 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2018 }
2019
2020 if (print_int_cst_bounds_in_octal_p (type, low, high))
2021 {
2022 stabstr_C ('r')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('r'))); })
;
2023
2024 /* If this type derives from another type, output type index of
2025 parent type. This is particularly important when parent type
2026 is an enumerated type, because not generating the parent type
2027 index would transform the definition of this enumerated type
2028 into a plain unsigned type. */
2029 if (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2029, __FUNCTION__))->typed.type)
!= 0)
2030 dbxout_type_index (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2030, __FUNCTION__))->typed.type)
);
2031 else
2032 dbxout_type_index (type);
2033
2034 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2035 stabstr_O (low);
2036 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2037 stabstr_O (high);
2038 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2039 }
2040
2041 else
2042 /* Output other integer types as subranges of `int'. */
2043 dbxout_range_type (type, low, high);
2044 }
2045
2046 break;
2047
2048 case REAL_TYPE:
2049 case FIXED_POINT_TYPE:
2050 /* This used to say `r1' and we used to take care
2051 to make sure that `int' was type number 1. */
2052 stabstr_C ('r')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('r'))); })
;
2053 dbxout_type_index (integer_type_nodeinteger_types[itk_int]);
2054 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2055 stabstr_D (int_size_in_bytes (type));
2056 stabstr_S (";0;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";0;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";0;", __len); __o->next_free += __len
; (void) 0; })
;
2057 break;
2058
2059 case BOOLEAN_TYPE:
2060 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2061 {
2062 stabstr_S ("@s")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("@s")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "@s", __len); __o->next_free += __len
; (void) 0; })
;
2063 stabstr_D (BITS_PER_UNIT(8) * int_size_in_bytes (type));
2064 stabstr_S (";-16;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";-16;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";-16;", __len); __o->next_free += __len
; (void) 0; })
;
2065 }
2066 else /* Define as enumeral type (False, True) */
2067 stabstr_S ("eFalse:0,True:1,;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("eFalse:0,True:1,;")); if (__extension__ ({
struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit
- __o1->next_free); }) < __len) _obstack_newchunk (__o
, __len); memcpy (__o->next_free, "eFalse:0,True:1,;", __len
); __o->next_free += __len; (void) 0; })
;
2068 break;
2069
2070 case COMPLEX_TYPE:
2071 /* Differs from the REAL_TYPE by its new data type number.
2072 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2073 codes since gdb doesn't care anyway. */
2074
2075 if (TREE_CODE (TREE_TYPE (type))((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2075, __FUNCTION__))->typed.type))->base.code)
== REAL_TYPE)
2076 {
2077 stabstr_S ("R3;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("R3;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "R3;", __len); __o->next_free += __len
; (void) 0; })
;
2078 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2078, __FUNCTION__))->typed.type)
));
2079 stabstr_S (";0;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";0;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";0;", __len); __o->next_free += __len
; (void) 0; })
;
2080 }
2081 else
2082 {
2083 /* Output a complex integer type as a structure,
2084 pending some other way to do it. */
2085 stabstr_C ('s')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('s'))); })
;
2086 stabstr_D (int_size_in_bytes (type));
2087
2088 stabstr_S ("real:")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("real:")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "real:", __len); __o->next_free += __len
; (void) 0; })
;
2089 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2089, __FUNCTION__))->typed.type)
, 0);
2090 stabstr_S (",0,")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (",0,")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ",0,", __len); __o->next_free += __len
; (void) 0; })
;
2091 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2091, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2091, __FUNCTION__))->type_common.precision)
);
2092
2093 stabstr_S (";imag:")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";imag:")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";imag:", __len); __o->next_free += __len
; (void) 0; })
;
2094 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2094, __FUNCTION__))->typed.type)
, 0);
2095 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2096 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2096, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2096, __FUNCTION__))->type_common.precision)
);
2097 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2098 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2098, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2098, __FUNCTION__))->type_common.precision)
);
2099 stabstr_S (";;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";;", __len); __o->next_free += __len
; (void) 0; })
;
2100 }
2101 break;
2102
2103 case ARRAY_TYPE:
2104 /* Make arrays of packed bits look like bitstrings for chill. */
2105 if (TYPE_PACKED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2105, __FUNCTION__))->base.u.bits.packed_flag)
&& use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2106 {
2107 stabstr_S ("@s")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("@s")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "@s", __len); __o->next_free += __len
; (void) 0; })
;
2108 stabstr_D (BITS_PER_UNIT(8) * int_size_in_bytes (type));
2109 stabstr_S (";@S;S")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";@S;S")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";@S;S", __len); __o->next_free += __len
; (void) 0; })
;
2110 dbxout_type (TYPE_DOMAIN (type)((tree_check ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2110, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
, 0);
2111 break;
2112 }
2113
2114 /* Output "a" followed by a range type definition
2115 for the index type of the array
2116 followed by a reference to the target-type.
2117 ar1;0;N;M for a C array of type M and size N+1. */
2118 /* Check if a character string type, which in Chill is
2119 different from an array of characters. */
2120 if (TYPE_STRING_FLAG (type)((tree_check2 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2120, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))->type_common
.string_flag)
&& use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2121 {
2122 stabstr_S ("@S;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("@S;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "@S;", __len); __o->next_free += __len
; (void) 0; })
;
2123 }
2124 tem = TYPE_DOMAIN (type)((tree_check ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2124, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)
;
2125 if (tem == NULLnullptr)
2126 {
2127 stabstr_S ("ar")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("ar")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "ar", __len); __o->next_free += __len
; (void) 0; })
;
2128 dbxout_type_index (integer_type_nodeinteger_types[itk_int]);
2129 stabstr_S (";0;-1;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (";0;-1;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ";0;-1;", __len); __o->next_free += __len
; (void) 0; })
;
2130 }
2131 else
2132 {
2133 stabstr_C ('a')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('a'))); })
;
2134 dbxout_range_type (tem, TYPE_MIN_VALUE (tem)((tree_check5 ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2134, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
, TYPE_MAX_VALUE (tem)((tree_check5 ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2134, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
);
2135 }
2136
2137 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2137, __FUNCTION__))->typed.type)
, 0);
2138 break;
2139
2140 case VECTOR_TYPE:
2141 /* Make vectors look like an array. */
2142 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2143 stabstr_S ("@V;")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("@V;")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "@V;", __len); __o->next_free += __len
; (void) 0; })
;
2144
2145 /* Output "a" followed by a range type definition
2146 for the index type of the array
2147 followed by a reference to the target-type.
2148 ar1;0;N;M for a C array of type M and size N+1. */
2149 stabstr_C ('a')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('a'))); })
;
2150 dbxout_range_type (integer_type_nodeinteger_types[itk_int], size_zero_nodeglobal_trees[TI_SIZE_ZERO],
2151 size_int (TYPE_VECTOR_SUBPARTS (type) - 1)size_int_kind (TYPE_VECTOR_SUBPARTS (type) - 1, stk_sizetype));
2152
2153 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2153, __FUNCTION__))->typed.type)
, 0);
2154 break;
2155
2156 case RECORD_TYPE:
2157 case UNION_TYPE:
2158 case QUAL_UNION_TYPE:
2159 {
2160 tree binfo = TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2160, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
2161
2162 /* Output a structure type. We must use the same test here as we
2163 use in the DBX_NO_XREFS case above. */
2164 if ((TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2164, __FUNCTION__))->type_common.name)
!= 0
2165 && ! (TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2165, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL
2166 && DECL_IGNORED_P (TYPE_NAME (type))((contains_struct_check ((((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2166, __FUNCTION__))->type_common.name)), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2166, __FUNCTION__))->decl_common.ignored_flag)
)
2167 && !full)
2168 || !COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2168, __FUNCTION__))->type_common.size) != (tree) nullptr
)
2169 /* No way in DBX fmt to describe a variable size. */
2170 || ! tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2170, __FUNCTION__))->type_common.size)
))
2171 {
2172 /* If the type is just a cross reference, output one
2173 and mark the type as partially described.
2174 If it later becomes defined, we will output
2175 its real definition.
2176 If the type has a name, don't nest its definition within
2177 another type's definition; instead, output an xref
2178 and let the definition come when the name is defined. */
2179 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ((((enum tree_code) (type)->base.code) ==
RECORD_TYPE) ? "xs" : "xu")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (((enum tree_code) (type)->base.code)
== RECORD_TYPE) ? "xs" : "xu", __len); __o->next_free += __len
; (void) 0; })
;
2180 if (TYPE_IDENTIFIER (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2180, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2180, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2180, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2180, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2180, __FUNCTION__))->type_common.name))
)
2181 {
2182 /* Note that the C frontend creates for anonymous variable
2183 length records/unions TYPE_NAME with DECL_NAME NULL. */
2184 dbxout_type_name (type);
2185 }
2186 else
2187 {
2188 stabstr_S ("$$")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("$$")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "$$", __len); __o->next_free += __len
; (void) 0; })
;
2189 stabstr_D (anonymous_type_number++);
2190 }
2191
2192 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
2193 typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2193, __FUNCTION__))->type_common.symtab.address)
].status = TYPE_XREF;
2194 break;
2195 }
2196
2197 /* Identify record or union, and print its size. */
2198 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ((((enum tree_code
) (type)->base.code) == RECORD_TYPE) ? 's' : 'u'))); })
;
2199 stabstr_D (int_size_in_bytes (type));
2200
2201 if (binfo)
2202 {
2203 int i;
2204 tree child;
2205 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2205, __FUNCTION__, (TREE_BINFO)))->binfo.base_accesses)
;
2206
2207 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2208 {
2209 if (BINFO_N_BASE_BINFOS (binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2209, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
length ())
)
2210 {
2211 stabstr_C ('!')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('!'))); })
;
2212 stabstr_U (BINFO_N_BASE_BINFOS (binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2212, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
length ())
);
2213 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2214 }
2215 }
2216 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2216, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((i), &(child)))
; i++)
2217 {
2218 tree access = (accesses ? (*accesses)[i] : access_public_nodeglobal_trees[TI_PUBLIC]);
2219
2220 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2221 {
2222 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (((tree_check (
(child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2222, __FUNCTION__, (TREE_BINFO)))->base.static_flag) ? '1'
: '0'))); })
;
2223 stabstr_C (access == access_public_node ? '2' :__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (access == global_trees
[TI_PUBLIC] ? '2' : access == global_trees[TI_PROTECTED] ? '1'
:'0'))); })
2224 access == access_protected_node__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (access == global_trees
[TI_PUBLIC] ? '2' : access == global_trees[TI_PROTECTED] ? '1'
:'0'))); })
2225 ? '1' :'0')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (access == global_trees
[TI_PUBLIC] ? '2' : access == global_trees[TI_PROTECTED] ? '1'
:'0'))); })
;
2226 if (BINFO_VIRTUAL_P (child)((tree_check ((child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2226, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
2227 && (lang_GNU_CXX ()
2228 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2229 /* For a virtual base, print the (negative)
2230 offset within the vtable where we must look
2231 to find the necessary adjustment. */
2232 stabstr_D
2233 (tree_to_shwi (BINFO_VPTR_FIELD (child)((tree_check ((child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2233, __FUNCTION__, (TREE_BINFO)))->binfo.vptr_field)
)
2234 * BITS_PER_UNIT(8));
2235 else
2236 stabstr_D (tree_to_shwi (BINFO_OFFSET (child)((tree_check ((child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2236, __FUNCTION__, (TREE_BINFO)))->binfo.offset)
)
2237 * BITS_PER_UNIT(8));
2238 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2239 dbxout_type (BINFO_TYPE (child)((contains_struct_check (((tree_check ((child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2239, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2239, __FUNCTION__))->typed.type)
, 0);
2240 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2241 }
2242 else
2243 {
2244 /* Print out the base class information with
2245 fields which have the same names at the types
2246 they hold. */
2247 dbxout_type_name (BINFO_TYPE (child)((contains_struct_check (((tree_check ((child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2247, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2247, __FUNCTION__))->typed.type)
);
2248 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
2249 dbxout_type (BINFO_TYPE (child)((contains_struct_check (((tree_check ((child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2249, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2249, __FUNCTION__))->typed.type)
, full);
2250 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2251 stabstr_D (tree_to_shwi (BINFO_OFFSET (child)((tree_check ((child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2251, __FUNCTION__, (TREE_BINFO)))->binfo.offset)
)
2252 * BITS_PER_UNIT(8));
2253 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2254 stabstr_D
2255 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child))((tree_class_check ((((contains_struct_check (((tree_check ((
child), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2255, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2255, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2255, __FUNCTION__))->type_common.size)
)
2256 * BITS_PER_UNIT(8));
2257 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2258 }
2259 }
2260 }
2261 }
2262
2263 /* Write out the field declarations. */
2264 dbxout_type_fields (type);
2265 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2266 dbxout_type_methods (type);
2267
2268 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2269
2270 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions && TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE
2271 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2272 && TYPE_VFIELD (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2272, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.minval)
)
2273 {
2274
2275 /* We need to write out info about what field this class
2276 uses as its "main" vtable pointer field, because if this
2277 field is inherited from a base class, GDB cannot necessarily
2278 figure out which field it's using in time. */
2279 stabstr_S ("~%")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("~%")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "~%", __len); __o->next_free += __len
; (void) 0; })
;
2280 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type))((tree_check ((((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2280, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.minval)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2280, __FUNCTION__, (FIELD_DECL)))->field_decl.fcontext)
, 0);
2281 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2282 }
2283 break;
2284
2285 case ENUMERAL_TYPE:
2286 /* We must use the same test here as we use in the DBX_NO_XREFS case
2287 above. We simplify it a bit since an enum will never have a variable
2288 size. */
2289 if ((TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2289, __FUNCTION__))->type_common.name)
!= 0
2290 && ! (TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2290, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL
2291 && DECL_IGNORED_P (TYPE_NAME (type))((contains_struct_check ((((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2291, __FUNCTION__))->type_common.name)), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2291, __FUNCTION__))->decl_common.ignored_flag)
)
2292 && !full)
2293 || !COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2293, __FUNCTION__))->type_common.size) != (tree) nullptr
)
)
2294 {
2295 stabstr_S ("xe")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("xe")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "xe", __len); __o->next_free += __len
; (void) 0; })
;
2296 dbxout_type_name (type);
2297 typevec[TYPE_SYMTAB_ADDRESS (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2297, __FUNCTION__))->type_common.symtab.address)
].status = TYPE_XREF;
2298 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
2299 return;
2300 }
2301 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
2302 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2302, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (integer_type_node)((tree_class_check ((integer_types[itk_int]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2302, __FUNCTION__))->type_common.precision)
)
2303 {
2304 stabstr_S ("@s")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("@s")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "@s", __len); __o->next_free += __len
; (void) 0; })
;
2305 stabstr_D (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2305, __FUNCTION__))->type_common.precision)
);
2306 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2307 }
2308
2309 stabstr_C ('e')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('e'))); })
;
2310 for (tem = TYPE_VALUES (type)((tree_check ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2310, __FUNCTION__, (ENUMERAL_TYPE)))->type_non_common.values
)
; tem; tem = TREE_CHAIN (tem)((contains_struct_check ((tem), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2310, __FUNCTION__))->common.chain)
)
2311 {
2312 tree value = TREE_VALUE (tem)((tree_check ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2312, __FUNCTION__, (TREE_LIST)))->list.value)
;
2313
2314 stabstr_I (TREE_PURPOSE (tem))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((((tree_check ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2314, __FUNCTION__, (TREE_LIST)))->list.purpose)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2314, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((((tree_check ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2314, __FUNCTION__, (TREE_LIST)))->list.purpose)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2314, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2315 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
2316
2317 if (TREE_CODE (value)((enum tree_code) (value)->base.code) == CONST_DECL)
2318 value = DECL_INITIAL (value)((contains_struct_check ((value), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2318, __FUNCTION__))->decl_common.initial)
;
2319
2320 if (cst_and_fits_in_hwi (value))
2321 stabstr_D (TREE_INT_CST_LOW (value)((unsigned long) (*tree_int_cst_elt_check ((value), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2321, __FUNCTION__)))
);
2322 else
2323 stabstr_O (value);
2324
2325 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2326 if (TREE_CHAIN (tem)((contains_struct_check ((tem), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2326, __FUNCTION__))->common.chain)
!= 0)
2327 CONTINstabstr_continue ();
2328 }
2329
2330 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2331 break;
2332
2333 case POINTER_TYPE:
2334 stabstr_C ('*')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('*'))); })
;
2335 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2335, __FUNCTION__))->typed.type)
, 0);
2336 break;
2337
2338 case METHOD_TYPE:
2339 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2340 {
2341 stabstr_C ('#')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('#'))); })
;
2342
2343 /* Write the argument types out longhand. */
2344 dbxout_type (TYPE_METHOD_BASETYPE (type)((tree_check2 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2344, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval)
, 0);
2345 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2346 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2346, __FUNCTION__))->typed.type)
, 0);
2347 dbxout_args (TYPE_ARG_TYPES (type)((tree_check2 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2347, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)
);
2348 stabstr_C (';')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (';'))); })
;
2349 }
2350 else
2351 /* Treat it as a function type. */
2352 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2352, __FUNCTION__))->typed.type)
, 0);
2353 break;
2354
2355 case OFFSET_TYPE:
2356 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2357 {
2358 stabstr_C ('@')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('@'))); })
;
2359 dbxout_type (TYPE_OFFSET_BASETYPE (type)((tree_check ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2359, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
)
, 0);
2360 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2361 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2361, __FUNCTION__))->typed.type)
, 0);
2362 }
2363 else
2364 /* Should print as an int, because it is really just an offset. */
2365 dbxout_type (integer_type_nodeinteger_types[itk_int], 0);
2366 break;
2367
2368 case REFERENCE_TYPE:
2369 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2370 {
2371 stabstr_C ('&')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('&'))); }
)
;
2372 }
2373 else
2374 stabstr_C ('*')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('*'))); })
;
2375 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2375, __FUNCTION__))->typed.type)
, 0);
2376 break;
2377
2378 case FUNCTION_TYPE:
2379 stabstr_C ('f')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('f'))); })
;
2380 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2380, __FUNCTION__))->typed.type)
, 0);
2381 break;
2382
2383 default:
2384 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2385 named 'auto' in its type.
2386 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2387 if (lang_GNU_CXX ())
2388 {
2389 tree name = TYPE_IDENTIFIER (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2389, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2389, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2389, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2389, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2389, __FUNCTION__))->type_common.name))
;
2390 if (name == get_identifier ("auto")(__builtin_constant_p ("auto") ? get_identifier_with_length (
("auto"), strlen ("auto")) : get_identifier ("auto"))
2391 || name == get_identifier ("decltype(auto)")(__builtin_constant_p ("decltype(auto)") ? get_identifier_with_length
(("decltype(auto)"), strlen ("decltype(auto)")) : get_identifier
("decltype(auto)"))
)
2392 break;
2393 }
2394
2395 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2395, __FUNCTION__))
;
2396 }
2397}
2398
2399/* Return nonzero if the given type represents an integer whose bounds
2400 should be printed in octal format. */
2401
2402static bool
2403print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
2404{
2405 /* If we can use GDB extensions and the size is wider than a long
2406 (the size used by GDB to read them) or we may have trouble writing
2407 the bounds the usual way, write them in octal. Note the test is for
2408 the *target's* size of "long", not that of the host. The host test
2409 is just to make sure we can write it out in case the host wide int
2410 is narrower than the target "long".
2411
2412 For unsigned types, we use octal if they are the same size or larger.
2413 This is because we print the bounds as signed decimal, and hence they
2414 can't span same size unsigned types. */
2415
2416 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
2417 && low && TREE_CODE (low)((enum tree_code) (low)->base.code) == INTEGER_CST
2418 && high && TREE_CODE (high)((enum tree_code) (high)->base.code) == INTEGER_CST
2419 && (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2419, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (integer_type_node)((tree_class_check ((integer_types[itk_int]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2419, __FUNCTION__))->type_common.precision)
2420 || ((TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2420, __FUNCTION__))->type_common.precision)
== TYPE_PRECISION (integer_type_node)((tree_class_check ((integer_types[itk_int]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2420, __FUNCTION__))->type_common.precision)
)
2421 && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2421, __FUNCTION__))->base.u.bits.unsigned_flag)
)
2422 || TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2422, __FUNCTION__))->type_common.precision)
> HOST_BITS_PER_WIDE_INT64
2423 || (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2423, __FUNCTION__))->type_common.precision)
== HOST_BITS_PER_WIDE_INT64
2424 && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2424, __FUNCTION__))->base.u.bits.unsigned_flag)
)))
2425 return TRUEtrue;
2426 else
2427 return FALSEfalse;
2428}
2429
2430/* Output the name of type TYPE, with no punctuation.
2431 Such names can be set up either by typedef declarations
2432 or by struct, enum and union tags. */
2433
2434static void
2435dbxout_type_name (tree type)
2436{
2437 tree t = TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2437, __FUNCTION__))->type_common.name)
;
2438
2439 gcc_assert (t)((void)(!(t) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2439, __FUNCTION__), 0 : 0))
;
2440 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
2441 {
2442 case IDENTIFIER_NODE:
2443 break;
2444 case TYPE_DECL:
2445 t = DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2445, __FUNCTION__))->decl_minimal.name)
;
2446 break;
2447 default:
2448 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2448, __FUNCTION__))
;
2449 }
2450
2451 stabstr_I (t)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2451, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2451, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2452}
2453
2454/* Output leading struct or class names needed for qualifying type
2455 whose scope is limited to a struct or class. */
2456
2457static void
2458dbxout_class_name_qualifiers (tree decl)
2459{
2460 tree context = decl_type_context (decl);
2461
2462 if (context != NULL_TREE(tree) nullptr
2463 && TREE_CODE (context)((enum tree_code) (context)->base.code) == RECORD_TYPE
2464 && TYPE_NAME (context)((tree_class_check ((context), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2464, __FUNCTION__))->type_common.name)
!= 0
2465 && (TREE_CODE (TYPE_NAME (context))((enum tree_code) (((tree_class_check ((context), (tcc_type),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2465, __FUNCTION__))->type_common.name))->base.code)
== IDENTIFIER_NODE
2466 || (DECL_NAME (TYPE_NAME (context))((contains_struct_check ((((tree_class_check ((context), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2466, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2466, __FUNCTION__))->decl_minimal.name)
!= 0)))
2467 {
2468 tree name = TYPE_NAME (context)((tree_class_check ((context), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2468, __FUNCTION__))->type_common.name)
;
2469
2470 if (TREE_CODE (name)((enum tree_code) (name)->base.code) == TYPE_DECL)
2471 {
2472 dbxout_class_name_qualifiers (name);
2473 name = DECL_NAME (name)((contains_struct_check ((name), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2473, __FUNCTION__))->decl_minimal.name)
;
2474 }
2475 stabstr_I (name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2475, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2475, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2476 stabstr_S ("::")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("::")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "::", __len); __o->next_free += __len
; (void) 0; })
;
2477 }
2478}
2479
2480/* This is a specialized subset of expand_expr for use by dbxout_symbol in
2481 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2482 haven't been expanded, or if the expression is getting so complex we won't
2483 be able to represent it in stabs anyway. Returns NULL on failure. */
2484
2485static rtx
2486dbxout_expand_expr (tree expr)
2487{
2488 switch (TREE_CODE (expr)((enum tree_code) (expr)->base.code))
2489 {
2490 case VAR_DECL:
2491 /* We can't handle emulated tls variables, because the address is an
2492 offset to the return value of __emutls_get_address, and there is no
2493 way to express that in stabs. Also, there are name mangling issues
2494 here. We end up with references to undefined symbols if we don't
2495 disable debug info for these variables. */
2496 if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr)((((expr)->base.static_flag) || ((contains_struct_check ((
expr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2496, __FUNCTION__))->decl_common.decl_flag_1)) &&
decl_tls_model (expr) >= TLS_MODEL_REAL)
)
2497 return NULLnullptr;
2498 if (TREE_STATIC (expr)((expr)->base.static_flag)
2499 && !TREE_ASM_WRITTEN (expr)((expr)->base.asm_written_flag)
2500 && !DECL_HAS_VALUE_EXPR_P (expr)((tree_check3 ((expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2500, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2)
2501 && !TREE_PUBLIC (expr)((expr)->base.public_flag)
2502 && DECL_RTL_SET_P (expr)(((tree_contains_struct[(((enum tree_code) (expr)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((expr
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2502, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
2503 && MEM_P (DECL_RTL (expr))(((enum rtx_code) (((contains_struct_check ((expr), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2503, __FUNCTION__))->decl_with_rtl.rtl ? (expr)->decl_with_rtl
.rtl : (make_decl_rtl (expr), (expr)->decl_with_rtl.rtl)))
->code) == MEM)
)
2504 {
2505 /* If this is a var that might not be actually output,
2506 return NULL, otherwise stabs might reference an undefined
2507 symbol. */
2508 varpool_node *node = varpool_node::get (expr);
2509 if (!node || !node->definition)
2510 return NULLnullptr;
2511 }
2512 /* FALLTHRU */
2513
2514 case PARM_DECL:
2515 case RESULT_DECL:
2516 if (DECL_HAS_VALUE_EXPR_P (expr)((tree_check3 ((expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2516, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2)
)
2517 return dbxout_expand_expr (DECL_VALUE_EXPR (expr)(decl_value_expr_lookup ((contains_struct_check ((expr), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2517, __FUNCTION__))))
);
2518 /* FALLTHRU */
2519
2520 case CONST_DECL:
2521 return DECL_RTL_IF_SET (expr)((((tree_contains_struct[(((enum tree_code) (expr)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((expr
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2521, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((expr), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2521, __FUNCTION__))->decl_with_rtl.rtl ? (expr)->decl_with_rtl
.rtl : (make_decl_rtl (expr), (expr)->decl_with_rtl.rtl)) :
nullptr)
;
2522
2523 case INTEGER_CST:
2524 return expand_expr (expr, NULL_RTX(rtx) 0, VOIDmode((void) 0, E_VOIDmode), EXPAND_INITIALIZER);
2525
2526 case COMPONENT_REF:
2527 case ARRAY_REF:
2528 case ARRAY_RANGE_REF:
2529 case BIT_FIELD_REF:
2530 {
2531 machine_mode mode;
2532 poly_int64 bitsize, bitpos;
2533 tree offset, tem;
2534 int unsignedp, reversep, volatilep = 0;
2535 rtx x;
2536
2537 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, &mode,
2538 &unsignedp, &reversep, &volatilep);
2539
2540 x = dbxout_expand_expr (tem);
2541 if (x == NULLnullptr || !MEM_P (x)(((enum rtx_code) (x)->code) == MEM))
2542 return NULLnullptr;
2543 if (offset != NULLnullptr)
2544 {
2545 if (!tree_fits_shwi_p (offset))
2546 return NULLnullptr;
2547 x = adjust_address_nv (x, mode, tree_to_shwi (offset))adjust_address_1 (x, mode, tree_to_shwi (offset), 0, 1, 0, 0);
2548 }
2549 if (maybe_ne (bitpos, 0))
2550 x = adjust_address_nv (x, mode, bits_to_bytes_round_down (bitpos))adjust_address_1 (x, mode, force_align_down_and_div (bitpos, (
8)), 0, 1, 0, 0)
;
2551
2552 return x;
2553 }
2554
2555 default:
2556 return NULLnullptr;
2557 }
2558}
2559
2560/* Helper function for output_used_types. Queue one entry from the
2561 used types hash to be output. */
2562
2563bool
2564output_used_types_helper (tree const &type, vec<tree> *types_p)
2565{
2566 if ((TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE
2567 || TREE_CODE (type)((enum tree_code) (type)->base.code) == UNION_TYPE
2568 || TREE_CODE (type)((enum tree_code) (type)->base.code) == QUAL_UNION_TYPE
2569 || TREE_CODE (type)((enum tree_code) (type)->base.code) == ENUMERAL_TYPE)
2570 && TYPE_STUB_DECL (type)(((contains_struct_check (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2570, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2570, __FUNCTION__))->common.chain))
2571 && DECL_P (TYPE_STUB_DECL (type))(tree_code_type[(int) (((enum tree_code) ((((contains_struct_check
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2571, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2571, __FUNCTION__))->common.chain)))->base.code))] ==
tcc_declaration)
2572 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type))((contains_struct_check (((((contains_struct_check (((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2572, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2572, __FUNCTION__))->common.chain))), (TS_DECL_COMMON),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2572, __FUNCTION__))->decl_common.ignored_flag)
)
2573 types_p->quick_push (TYPE_STUB_DECL (type)(((contains_struct_check (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2573, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2573, __FUNCTION__))->common.chain))
);
2574 else if (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2574, __FUNCTION__))->type_common.name)
2575 && TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2575, __FUNCTION__))->type_common.name))->base.code)
== TYPE_DECL)
2576 types_p->quick_push (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2576, __FUNCTION__))->type_common.name)
);
2577
2578 return true;
2579}
2580
2581/* This is a qsort callback which sorts types and declarations into a
2582 predictable order (types, then declarations, sorted by UID
2583 within). */
2584
2585static int
2586output_types_sort (const void *pa, const void *pb)
2587{
2588 const tree lhs = *((const tree *)pa);
2589 const tree rhs = *((const tree *)pb);
2590
2591 if (TYPE_P (lhs)(tree_code_type[(int) (((enum tree_code) (lhs)->base.code)
)] == tcc_type)
)
2592 {
2593 if (TYPE_P (rhs)(tree_code_type[(int) (((enum tree_code) (rhs)->base.code)
)] == tcc_type)
)
2594 return TYPE_UID (lhs)((tree_class_check ((lhs), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2594, __FUNCTION__))->type_common.uid)
- TYPE_UID (rhs)((tree_class_check ((rhs), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2594, __FUNCTION__))->type_common.uid)
;
2595 else
2596 return 1;
2597 }
2598 else
2599 {
2600 if (TYPE_P (rhs)(tree_code_type[(int) (((enum tree_code) (rhs)->base.code)
)] == tcc_type)
)
2601 return -1;
2602 else
2603 return DECL_UID (lhs)((contains_struct_check ((lhs), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2603, __FUNCTION__))->decl_minimal.uid)
- DECL_UID (rhs)((contains_struct_check ((rhs), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2603, __FUNCTION__))->decl_minimal.uid)
;
2604 }
2605}
2606
2607
2608/* Force all types used by this function to be output in debug
2609 information. */
2610
2611static void
2612output_used_types (void)
2613{
2614 if (cfun(cfun + 0) && cfun(cfun + 0)->used_types_hash)
2615 {
2616 vec<tree> types;
2617 int i;
2618 tree type;
2619
2620 types.create (cfun(cfun + 0)->used_types_hash->elements ());
2621 cfun(cfun + 0)->used_types_hash->traverse<vec<tree> *, output_used_types_helper>
2622 (&types);
2623
2624 /* Sort by UID to prevent dependence on hash table ordering. */
2625 types.qsort (output_types_sort)qsort (output_types_sort);
2626
2627 FOR_EACH_VEC_ELT (types, i, type)for (i = 0; (types).iterate ((i), &(type)); ++(i))
2628 debug_queue_symbol (type);
2629
2630 types.release ();
2631 }
2632}
2633
2634/* Output a .stabs for the symbol defined by DECL,
2635 which must be a ..._DECL node in the normal namespace.
2636 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2637 LOCAL is nonzero if the scope is less than the entire file.
2638 Return 1 if a stabs might have been emitted. */
2639
2640int
2641dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2642{
2643 tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2643, __FUNCTION__))->typed.type)
;
2644 tree context = NULL_TREE(tree) nullptr;
2645 int result = 0;
2646 rtx decl_rtl;
2647
2648 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2649 ++debug_nesting;
2650
2651 /* Ignore nameless syms, but don't ignore type tags. */
2652
2653 if ((DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2653, __FUNCTION__))->decl_minimal.name)
== 0 && TREE_CODE (decl)((enum tree_code) (decl)->base.code) != TYPE_DECL)
2654 || DECL_IGNORED_P (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2654, __FUNCTION__))->decl_common.ignored_flag)
)
2655 DBXOUT_DECR_NESTING_AND_RETURN (0)do {--debug_nesting; return (0);} while (0);
2656
2657 /* If we are to generate only the symbols actually used then such
2658 symbol nodes are flagged with TREE_USED. Ignore any that
2659 aren't flagged as TREE_USED. */
2660
2661 if (flag_debug_only_used_symbolsglobal_options.x_flag_debug_only_used_symbols
2662 && (!TREE_USED (decl)((decl)->base.used_flag)
2663 && (!VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL) || !DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2663, __FUNCTION__))->decl_common.initial)
)))
2664 DBXOUT_DECR_NESTING_AND_RETURN (0)do {--debug_nesting; return (0);} while (0);
2665
2666 /* If dbxout_init has not yet run, queue this symbol for later. */
2667 if (!typevec)
2668 {
2669 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2670 DBXOUT_DECR_NESTING_AND_RETURN (0)do {--debug_nesting; return (0);} while (0);
2671 }
2672
2673 if (flag_debug_only_used_symbolsglobal_options.x_flag_debug_only_used_symbols)
2674 {
2675 tree t;
2676
2677 /* We now have a used symbol. We need to generate the info for
2678 the symbol's type in addition to the symbol itself. These
2679 type symbols are queued to be generated after were done with
2680 the symbol itself (otherwise they would fight over the
2681 stabstr obstack).
2682
2683 Note, because the TREE_TYPE(type) might be something like a
2684 pointer to a named type we need to look for the first name
2685 we see following the TREE_TYPE chain. */
2686
2687 t = type;
2688 while (POINTER_TYPE_P (t)(((enum tree_code) (t)->base.code) == POINTER_TYPE || ((enum
tree_code) (t)->base.code) == REFERENCE_TYPE)
)
2689 t = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2689, __FUNCTION__))->typed.type)
;
2690
2691 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2692 need special treatment. The TYPE_STUB_DECL field in these
2693 types generally represents the tag name type we want to
2694 output. In addition there could be a typedef type with
2695 a different name. In that case we also want to output
2696 that. */
2697
2698 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == RECORD_TYPE
2699 || TREE_CODE (t)((enum tree_code) (t)->base.code) == UNION_TYPE
2700 || TREE_CODE (t)((enum tree_code) (t)->base.code) == QUAL_UNION_TYPE
2701 || TREE_CODE (t)((enum tree_code) (t)->base.code) == ENUMERAL_TYPE)
2702 {
2703 if (TYPE_STUB_DECL (t)(((contains_struct_check (((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2703, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2703, __FUNCTION__))->common.chain))
2704 && TYPE_STUB_DECL (t)(((contains_struct_check (((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2704, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2704, __FUNCTION__))->common.chain))
!= decl
2705 && DECL_P (TYPE_STUB_DECL (t))(tree_code_type[(int) (((enum tree_code) ((((contains_struct_check
(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2705, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2705, __FUNCTION__))->common.chain)))->base.code))] ==
tcc_declaration)
2706 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t))((contains_struct_check (((((contains_struct_check (((tree_class_check
((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2706, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2706, __FUNCTION__))->common.chain))), (TS_DECL_COMMON),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2706, __FUNCTION__))->decl_common.ignored_flag)
)
2707 {
2708 debug_queue_symbol (TYPE_STUB_DECL (t)(((contains_struct_check (((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2708, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2708, __FUNCTION__))->common.chain))
);
2709 if (TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2709, __FUNCTION__))->type_common.name)
2710 && TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2710, __FUNCTION__))->type_common.name)
!= TYPE_STUB_DECL (t)(((contains_struct_check (((tree_class_check ((t), (tcc_type)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2710, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2710, __FUNCTION__))->common.chain))
2711 && TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2711, __FUNCTION__))->type_common.name)
!= decl
2712 && DECL_P (TYPE_NAME (t))(tree_code_type[(int) (((enum tree_code) (((tree_class_check (
(t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2712, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration)
)
2713 debug_queue_symbol (TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2713, __FUNCTION__))->type_common.name)
);
2714 }
2715 }
2716 else if (TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2716, __FUNCTION__))->type_common.name)
2717 && TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2717, __FUNCTION__))->type_common.name)
!= decl
2718 && DECL_P (TYPE_NAME (t))(tree_code_type[(int) (((enum tree_code) (((tree_class_check (
(t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2718, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration)
)
2719 debug_queue_symbol (TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2719, __FUNCTION__))->type_common.name)
);
2720 }
2721
2722 emit_pending_bincls_if_required ();
2723
2724 switch (TREE_CODE (decl)((enum tree_code) (decl)->base.code))
2725 {
2726 case CONST_DECL:
2727 /* Enum values are defined by defining the enum type. */
2728 break;
2729
2730 case FUNCTION_DECL:
2731 decl_rtl = DECL_RTL_IF_SET (decl)((((tree_contains_struct[(((enum tree_code) (decl)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((decl
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2731, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((decl), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2731, __FUNCTION__))->decl_with_rtl.rtl ? (decl)->decl_with_rtl
.rtl : (make_decl_rtl (decl), (decl)->decl_with_rtl.rtl)) :
nullptr)
;
2732 if (!decl_rtl)
2733 DBXOUT_DECR_NESTING_AND_RETURN (0)do {--debug_nesting; return (0);} while (0);
2734 if (DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2734, __FUNCTION__))->decl_common.decl_flag_1)
)
2735 break;
2736 /* Don't mention a nested function under its parent. */
2737 context = decl_function_context (decl);
2738 if (context == current_function_decl)
2739 break;
2740 /* Don't mention an inline instance of a nested function. */
2741 if (context && DECL_FROM_INLINE (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2741, __FUNCTION__))->decl_common.abstract_origin) != (tree
) nullptr && ((contains_struct_check ((decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2741, __FUNCTION__))->decl_common.abstract_origin) != (decl
))
)
2742 break;
2743 if (!MEM_P (decl_rtl)(((enum rtx_code) (decl_rtl)->code) == MEM)
2744 || GET_CODE (XEXP (decl_rtl, 0))((enum rtx_code) ((((decl_rtl)->u.fld[0]).rt_rtx))->code
)
!= SYMBOL_REF)
2745 break;
2746
2747 if (flag_debug_only_used_symbolsglobal_options.x_flag_debug_only_used_symbols)
2748 output_used_types ();
2749
2750 dbxout_begin_complex_stabs ();
2751 stabstr_I (DECL_ASSEMBLER_NAME (decl))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((decl_assembler_name (decl)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2751, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((decl_assembler_name (decl)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2751, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2752 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (((decl)->base.public_flag) ? ":F" : ":f"
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(decl)->base.public_flag) ? ":F" : ":f", __len); __o->next_free
+= __len; (void) 0; })
;
2753 result = 1;
2754
2755 if (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2755, __FUNCTION__))->typed.type)
)
2756 dbxout_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2756, __FUNCTION__))->typed.type)
, 0);
2757 else
2758 dbxout_type (void_type_nodeglobal_trees[TI_VOID_TYPE], 0);
2759
2760 /* For a nested function, when that function is compiled,
2761 mention the containing function name
2762 as well as (since dbx wants it) our own assembler-name. */
2763 if (context != 0)
2764 {
2765 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2766 stabstr_I (DECL_ASSEMBLER_NAME (decl))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((decl_assembler_name (decl)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2766, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((decl_assembler_name (decl)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2766, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2767 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
2768 stabstr_I (DECL_NAME (context))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((((contains_struct_check ((context), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2768, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2768, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((((contains_struct_check ((context
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2768, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2768, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2769 }
2770
2771 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0)(((decl_rtl)->u.fld[0]).rt_rtx), 0, 0);
2772 break;
2773
2774 case TYPE_DECL:
2775 /* Don't output the same typedef twice.
2776 And don't output what language-specific stuff doesn't want output. */
2777 if (TREE_ASM_WRITTEN (decl)((decl)->base.asm_written_flag) || TYPE_DECL_SUPPRESS_DEBUG (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2777, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
)
2778 DBXOUT_DECR_NESTING_AND_RETURN (0)do {--debug_nesting; return (0);} while (0);
2779
2780 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2781#ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2782 {
2783 int fundamental_type_number =
2784 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2785
2786 if (fundamental_type_number != 0)
2787 {
2788 TREE_ASM_WRITTEN (decl)((decl)->base.asm_written_flag) = 1;
2789 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl))((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2789, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2789, __FUNCTION__))->type_common.symtab.address)
= fundamental_type_number;
2790 DBXOUT_DECR_NESTING_AND_RETURN (0)do {--debug_nesting; return (0);} while (0);
2791 }
2792 }
2793#endif
2794 FORCE_TEXT;
2795 result = 1;
2796 {
2797 int tag_needed = 1;
2798 int did_output = 0;
2799
2800 if (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2800, __FUNCTION__))->decl_minimal.name)
)
2801 {
2802 /* Nonzero means we must output a tag as well as a typedef. */
2803 tag_needed = 0;
2804
2805 /* Handle the case of a C++ structure or union
2806 where the TYPE_NAME is a TYPE_DECL
2807 which gives both a typedef name and a tag. */
2808 /* dbx requires the tag first and the typedef second. */
2809 if ((TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE
2810 || TREE_CODE (type)((enum tree_code) (type)->base.code) == UNION_TYPE
2811 || TREE_CODE (type)((enum tree_code) (type)->base.code) == QUAL_UNION_TYPE)
2812 && TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2812, __FUNCTION__))->type_common.name)
== decl
2813 && !use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
2814 && !TREE_ASM_WRITTEN (TYPE_NAME (type))((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2814, __FUNCTION__))->type_common.name))->base.asm_written_flag
)
2815 /* Distinguish the implicit typedefs of C++
2816 from explicit ones that might be found in C. */
2817 && DECL_ARTIFICIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2817, __FUNCTION__))->decl_common.artificial_flag)
2818 /* Do not generate a tag for incomplete records. */
2819 && COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2819, __FUNCTION__))->type_common.size) != (tree) nullptr
)
2820 /* Do not generate a tag for records of variable size,
2821 since this type cannot be properly described in the
2822 DBX format, and it confuses some tools such as objdump. */
2823 && tree_fits_uhwi_p (TYPE_SIZE (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2823, __FUNCTION__))->type_common.size)
))
2824 {
2825 tree name = TYPE_IDENTIFIER (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2825, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2825, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2825, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2825, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2825, __FUNCTION__))->type_common.name))
;
2826
2827 dbxout_begin_complex_stabs ();
2828 stabstr_I (name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2828, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2828, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2829 stabstr_S (":T")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (":T")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ":T", __len); __o->next_free += __len
; (void) 0; })
;
2830 dbxout_type (type, 1);
2831 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODEN_LSYM,
2832 0, 0, 0);
2833 }
2834
2835 dbxout_begin_complex_stabs ();
2836
2837 /* Output leading class/struct qualifiers. */
2838 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2839 dbxout_class_name_qualifiers (decl);
2840
2841 /* Output typedef name. */
2842 stabstr_I (DECL_NAME (decl))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2842, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2842, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((((contains_struct_check ((decl),
(TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2842, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2842, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2843 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
2844
2845 /* Short cut way to output a tag also. */
2846 if ((TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE
2847 || TREE_CODE (type)((enum tree_code) (type)->base.code) == UNION_TYPE
2848 || TREE_CODE (type)((enum tree_code) (type)->base.code) == QUAL_UNION_TYPE)
2849 && TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2849, __FUNCTION__))->type_common.name)
== decl
2850 /* Distinguish the implicit typedefs of C++
2851 from explicit ones that might be found in C. */
2852 && DECL_ARTIFICIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2852, __FUNCTION__))->decl_common.artificial_flag)
)
2853 {
2854 if (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions)
2855 {
2856 stabstr_C ('T')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('T'))); })
;
2857 TREE_ASM_WRITTEN (TYPE_NAME (type))((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2857, __FUNCTION__))->type_common.name))->base.asm_written_flag
)
= 1;
2858 }
2859 }
2860
2861 stabstr_C ('t')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ('t'))); })
;
2862 dbxout_type (type, 1);
2863 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODEN_LSYM,
2864 0, 0, 0);
2865 did_output = 1;
2866 }
2867
2868 /* Don't output a tag if this is an incomplete type. This prevents
2869 the sun4 Sun OS 4.x dbx from crashing. */
2870
2871 if (tag_needed && TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2871, __FUNCTION__))->type_common.name)
!= 0
2872 && (TREE_CODE (TYPE_NAME (type))((enum tree_code) (((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2872, __FUNCTION__))->type_common.name))->base.code)
== IDENTIFIER_NODE
2873 || (DECL_NAME (TYPE_NAME (type))((contains_struct_check ((((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2873, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2873, __FUNCTION__))->decl_minimal.name)
!= 0))
2874 && COMPLETE_TYPE_P (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2874, __FUNCTION__))->type_common.size) != (tree) nullptr
)
2875 && !TREE_ASM_WRITTEN (TYPE_NAME (type))((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2875, __FUNCTION__))->type_common.name))->base.asm_written_flag
)
)
2876 {
2877 /* For a TYPE_DECL with no name, but the type has a name,
2878 output a tag.
2879 This is what represents `struct foo' with no typedef. */
2880 /* In C++, the name of a type is the corresponding typedef.
2881 In C, it is an IDENTIFIER_NODE. */
2882 tree name = TYPE_IDENTIFIER (type)(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2882, __FUNCTION__))->type_common.name) && (tree_code_type
[(int) (((enum tree_code) (((tree_class_check ((type), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2882, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2882, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2882, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2882, __FUNCTION__))->type_common.name))
;
2883
2884 dbxout_begin_complex_stabs ();
2885 stabstr_I (name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2885, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2885, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
2886 stabstr_S (":T")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (":T")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ":T", __len); __o->next_free += __len
; (void) 0; })
;
2887 dbxout_type (type, 1);
2888 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODEN_LSYM, 0, 0, 0);
2889 did_output = 1;
2890 }
2891
2892 /* If an enum type has no name, it cannot be referred to, but
2893 we must output it anyway, to record the enumeration
2894 constants. */
2895
2896 if (!did_output && TREE_CODE (type)((enum tree_code) (type)->base.code) == ENUMERAL_TYPE)
2897 {
2898 dbxout_begin_complex_stabs ();
2899 /* Some debuggers fail when given NULL names, so give this a
2900 harmless name of " " (Why not "(anon)"?). */
2901 stabstr_S (" :T")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (" :T")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, " :T", __len); __o->next_free += __len
; (void) 0; })
;
2902 dbxout_type (type, 1);
2903 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODEN_LSYM, 0, 0, 0);
2904 }
2905
2906 /* Prevent duplicate output of a typedef. */
2907 TREE_ASM_WRITTEN (decl)((decl)->base.asm_written_flag) = 1;
2908 break;
2909 }
2910
2911 case PARM_DECL:
2912 if (DECL_HAS_VALUE_EXPR_P (decl)((tree_check3 ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2912, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2)
)
2913 decl = DECL_VALUE_EXPR (decl)(decl_value_expr_lookup ((contains_struct_check ((decl), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2913, __FUNCTION__))))
;
2914
2915 /* PARM_DECLs go in their own separate chain and are output by
2916 dbxout_reg_parms and dbxout_parms, except for those that are
2917 disguised VAR_DECLs like Out parameters in Ada. */
2918 gcc_assert (VAR_P (decl))((void)(!((((enum tree_code) (decl)->base.code) == VAR_DECL
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2918, __FUNCTION__), 0 : 0))
;
2919
2920 /* fall through */
2921
2922 case RESULT_DECL:
2923 case VAR_DECL:
2924 /* Don't mention a variable that is external.
2925 Let the file that defines it describe it. */
2926 if (DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2926, __FUNCTION__))->decl_common.decl_flag_1)
)
2927 break;
2928
2929 /* If the variable is really a constant
2930 and not written in memory, inform the debugger.
2931
2932 ??? Why do we skip emitting the type and location in this case? */
2933 if (TREE_STATIC (decl)((decl)->base.static_flag) && TREE_READONLY (decl)((non_type_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2933, __FUNCTION__))->base.readonly_flag)
2934 && DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2934, __FUNCTION__))->decl_common.initial)
!= 0
2935 && tree_fits_shwi_p (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2935, __FUNCTION__))->decl_common.initial)
)
2936 && ! TREE_ASM_WRITTEN (decl)((decl)->base.asm_written_flag)
2937 && (DECL_FILE_SCOPE_P (decl)(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2937, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2937, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL)
2938 || TREE_CODE (DECL_CONTEXT (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2938, __FUNCTION__))->decl_minimal.context))->base.code
)
== BLOCK
2939 || TREE_CODE (DECL_CONTEXT (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2939, __FUNCTION__))->decl_minimal.context))->base.code
)
== NAMESPACE_DECL)
2940 && TREE_PUBLIC (decl)((decl)->base.public_flag) == 0)
2941 {
2942 /* The sun4 assembler does not grok this. */
2943
2944 if (TREE_CODE (TREE_TYPE (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2944, __FUNCTION__))->typed.type))->base.code)
== INTEGER_TYPE
2945 || TREE_CODE (TREE_TYPE (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2945, __FUNCTION__))->typed.type))->base.code)
== ENUMERAL_TYPE)
2946 {
2947 HOST_WIDE_INTlong ival = tree_to_shwi (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 2947, __FUNCTION__))->decl_common.initial)
);
2948
2949 dbxout_begin_complex_stabs ();
2950 dbxout_symbol_name (decl, NULLnullptr, 'c');
2951 stabstr_S ("=i")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("=i")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "=i", __len); __o->next_free += __len
; (void) 0; })
;
2952 stabstr_D (ival);
2953 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2954 DBXOUT_DECR_NESTINGif (--debug_nesting == 0 && symbol_queue_index > 0
) { emit_pending_bincls_if_required (); debug_flush_symbol_queue
(); }
;
2955 return 1;
2956 }
2957 else
2958 break;
2959 }
2960 /* else it is something we handle like a normal variable. */
2961
2962 decl_rtl = dbxout_expand_expr (decl);
2963 if (!decl_rtl)
2964 DBXOUT_DECR_NESTING_AND_RETURN (0)do {--debug_nesting; return (0);} while (0);
2965
2966 if (!is_global_var (decl))
2967 decl_rtl = eliminate_regs (decl_rtl, VOIDmode((void) 0, E_VOIDmode), NULL_RTX(rtx) 0);
2968#ifdef LEAF_REG_REMAP
2969 if (crtl(&x_rtl)->uses_only_leaf_regs)
2970 leaf_renumber_regs_insn (decl_rtl);
2971#endif
2972
2973 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2974 break;
2975
2976 default:
2977 break;
2978 }
2979 DBXOUT_DECR_NESTINGif (--debug_nesting == 0 && symbol_queue_index > 0
) { emit_pending_bincls_if_required (); debug_flush_symbol_queue
(); }
;
2980 return result;
2981}
2982
2983/* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2984 Add SUFFIX to its name, if SUFFIX is not 0.
2985 Describe the variable as residing in HOME
2986 (usually HOME is DECL_RTL (DECL), but not always).
2987 Returns 1 if the stab was really emitted. */
2988
2989static int
2990dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2991{
2992 int letter = 0;
2993 stab_code_type code;
2994 rtx addr = 0;
2995 int number = 0;
2996 int regno = -1;
2997
2998 /* Don't mention a variable at all
2999 if it was completely optimized into nothingness.
3000
3001 If the decl was from an inline function, then its rtl
3002 is not identically the rtl that was used in this
3003 particular compilation. */
3004 if (GET_CODE (home)((enum rtx_code) (home)->code) == SUBREG)
3005 {
3006 rtx value = home;
3007
3008 while (GET_CODE (value)((enum rtx_code) (value)->code) == SUBREG)
3009 value = SUBREG_REG (value)(((value)->u.fld[0]).rt_rtx);
3010 if (REG_P (value)(((enum rtx_code) (value)->code) == REG))
3011 {
3012 if (REGNO (value)(rhs_regno(value)) >= FIRST_PSEUDO_REGISTER76)
3013 return 0;
3014 }
3015 home = alter_subreg (&home, true);
3016 }
3017 if (REG_P (home)(((enum rtx_code) (home)->code) == REG))
3018 {
3019 regno = REGNO (home)(rhs_regno(home));
3020 if (regno >= FIRST_PSEUDO_REGISTER76)
3021 return 0;
3022 }
3023
3024 /* The kind-of-variable letter depends on where
3025 the variable is and on the scope of its name:
3026 G and N_GSYM for static storage and global scope,
3027 S for static storage and file scope,
3028 V for static storage and local scope,
3029 for those two, use N_LCSYM if data is in bss segment,
3030 N_STSYM if in data segment, N_FUN otherwise.
3031 (We used N_FUN originally, then changed to N_STSYM
3032 to please GDB. However, it seems that confused ld.
3033 Now GDB has been fixed to like N_FUN, says Kingdon.)
3034 no letter at all, and N_LSYM, for auto variable,
3035 r and N_RSYM for register variable. */
3036
3037 if (MEM_P (home)(((enum rtx_code) (home)->code) == MEM) && GET_CODE (XEXP (home, 0))((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) == SYMBOL_REF)
3038 {
3039 if (TREE_PUBLIC (decl)((decl)->base.public_flag))
3040 {
3041 int offs;
3042 letter = 'G';
3043 code = N_GSYM;
3044 if (dbxout_common_check (decl, &offs) != NULLnullptr)
3045 {
3046 letter = 'V';
3047 addr = 0;
3048 number = offs;
3049 }
3050 }
3051 else
3052 {
3053 addr = XEXP (home, 0)(((home)->u.fld[0]).rt_rtx);
3054
3055 letter = decl_function_context (decl) ? 'V' : 'S';
3056
3057 /* Some ports can transform a symbol ref into a label ref,
3058 because the symbol ref is too far away and has to be
3059 dumped into a constant pool. Alternatively, the symbol
3060 in the constant pool might be referenced by a different
3061 symbol. */
3062 if (GET_CODE (addr)((enum rtx_code) (addr)->code) == SYMBOL_REF
3063 && CONSTANT_POOL_ADDRESS_P (addr)(__extension__ ({ __typeof ((addr)) const _rtx = ((addr)); if
(((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3063, __FUNCTION__); _rtx; })->unchanging)
)
3064 {
3065 bool marked;
3066 rtx tmp = get_pool_constant_mark (addr, &marked);
3067
3068 if (GET_CODE (tmp)((enum rtx_code) (tmp)->code) == SYMBOL_REF)
3069 {
3070 addr = tmp;
3071 if (CONSTANT_POOL_ADDRESS_P (addr)(__extension__ ({ __typeof ((addr)) const _rtx = ((addr)); if
(((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3071, __FUNCTION__); _rtx; })->unchanging)
)
3072 get_pool_constant_mark (addr, &marked);
3073 else
3074 marked = true;
3075 }
3076 else if (GET_CODE (tmp)((enum rtx_code) (tmp)->code) == LABEL_REF)
3077 {
3078 addr = tmp;
3079 marked = true;
3080 }
3081
3082 /* If all references to the constant pool were optimized
3083 out, we just ignore the symbol. */
3084 if (!marked)
3085 return 0;
3086 }
3087
3088 /* This should be the same condition as in assemble_variable, but
3089 we don't have access to dont_output_data here. So, instead,
3090 we rely on the fact that error_mark_node initializers always
3091 end up in bss for C++ and never end up in bss for C. */
3092 if (DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3092, __FUNCTION__))->decl_common.initial)
== 0
3093 || (lang_GNU_CXX ()
3094 && DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3094, __FUNCTION__))->decl_common.initial)
== error_mark_nodeglobal_trees[TI_ERROR_MARK]))
3095 {
3096 int offs;
3097 code = N_LCSYM;
3098 if (dbxout_common_check (decl, &offs) != NULLnullptr)
3099 {
3100 addr = 0;
3101 number = offs;
3102 letter = 'V';
3103 code = N_GSYM;
3104 }
3105 }
3106 else if (DECL_IN_TEXT_SECTION (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3106, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_text_section
)
)
3107 /* This is not quite right, but it's the closest
3108 of all the codes that Unix defines. */
3109 code = DBX_STATIC_CONST_VAR_CODEN_FUN;
3110 else
3111 {
3112 /* Ultrix `as' seems to need this. */
3113#ifdef DBX_STATIC_STAB_DATA_SECTION
3114 switch_to_section (data_section);
3115#endif
3116 code = N_STSYM;
3117 }
3118 }
3119 }
3120 else if (regno >= 0)
3121 {
3122 letter = 'r';
3123 code = N_RSYM;
3124 number = DBX_REGISTER_NUMBER (regno)(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
0) ? dbx64_register_map[regno] : svr4_dbx_register_map[regno
])
;
3125 }
3126 else if (MEM_P (home)(((enum rtx_code) (home)->code) == MEM)
3127 && (MEM_P (XEXP (home, 0))(((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) ==
MEM)
3128 || (REG_P (XEXP (home, 0))(((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) ==
REG)
3129 && REGNO (XEXP (home, 0))(rhs_regno((((home)->u.fld[0]).rt_rtx))) != HARD_FRAME_POINTER_REGNUM6
3130 && REGNO (XEXP (home, 0))(rhs_regno((((home)->u.fld[0]).rt_rtx))) != STACK_POINTER_REGNUM7
3131#if !HARD_FRAME_POINTER_IS_ARG_POINTER(6 == 16)
3132 && REGNO (XEXP (home, 0))(rhs_regno((((home)->u.fld[0]).rt_rtx))) != ARG_POINTER_REGNUM16
3133#endif
3134 )))
3135 /* If the value is indirect by memory or by a register
3136 that isn't the frame pointer
3137 then it means the object is variable-sized and address through
3138 that register or stack slot. DBX has no way to represent this
3139 so all we can do is output the variable as a pointer.
3140 If it's not a parameter, ignore it. */
3141 {
3142 if (REG_P (XEXP (home, 0))(((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) ==
REG)
)
3143 {
3144 letter = 'r';
3145 code = N_RSYM;
3146 if (REGNO (XEXP (home, 0))(rhs_regno((((home)->u.fld[0]).rt_rtx))) >= FIRST_PSEUDO_REGISTER76)
3147 return 0;
3148 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)))(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
0) ? dbx64_register_map[(rhs_regno((((home)->u.fld[0]).rt_rtx
)))] : svr4_dbx_register_map[(rhs_regno((((home)->u.fld[0]
).rt_rtx)))])
;
3149 }
3150 else
3151 {
3152 code = N_LSYM;
3153 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3154 We want the value of that CONST_INT. */
3155 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0))(((enum rtx_code) (((((((home)->u.fld[0]).rt_rtx))->u.fld
[0]).rt_rtx))->code) == PLUS ? (((((((((((home)->u.fld[
0]).rt_rtx))->u.fld[0]).rt_rtx))->u.fld[1]).rt_rtx))->
u.hwint[0]) : 0)
;
3156 }
3157
3158 /* Effectively do build_pointer_type, but don't cache this type,
3159 since it might be temporary whereas the type it points to
3160 might have been saved for inlining. */
3161 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3162 type = make_node (POINTER_TYPE);
3163 TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3163, __FUNCTION__))->typed.type)
= TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3163, __FUNCTION__))->typed.type)
;
3164 }
3165 else if (MEM_P (home)(((enum rtx_code) (home)->code) == MEM)
3166 && REG_P (XEXP (home, 0))(((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) ==
REG)
)
3167 {
3168 code = N_LSYM;
3169 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0))(((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) ==
PLUS ? ((((((((home)->u.fld[0]).rt_rtx))->u.fld[1]).rt_rtx
))->u.hwint[0]) : 0)
;
3170 }
3171 else if (MEM_P (home)(((enum rtx_code) (home)->code) == MEM)
3172 && GET_CODE (XEXP (home, 0))((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) == PLUS
3173 && CONST_INT_P (XEXP (XEXP (home, 0), 1))(((enum rtx_code) (((((((home)->u.fld[0]).rt_rtx))->u.fld
[1]).rt_rtx))->code) == CONST_INT)
)
3174 {
3175 code = N_LSYM;
3176 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3177 We want the value of that CONST_INT. */
3178 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0))(((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) ==
PLUS ? ((((((((home)->u.fld[0]).rt_rtx))->u.fld[1]).rt_rtx
))->u.hwint[0]) : 0)
;
3179 }
3180 else if (MEM_P (home)(((enum rtx_code) (home)->code) == MEM)
3181 && GET_CODE (XEXP (home, 0))((enum rtx_code) ((((home)->u.fld[0]).rt_rtx))->code) == CONST)
3182 {
3183 /* Handle an obscure case which can arise when optimizing and
3184 when there are few available registers. (This is *always*
3185 the case for i386/i486 targets). The RTL looks like
3186 (MEM (CONST ...)) even though this variable is a local `auto'
3187 or a local `register' variable. In effect, what has happened
3188 is that the reload pass has seen that all assignments and
3189 references for one such a local variable can be replaced by
3190 equivalent assignments and references to some static storage
3191 variable, thereby avoiding the need for a register. In such
3192 cases we're forced to lie to debuggers and tell them that
3193 this variable was itself `static'. */
3194 int offs;
3195 code = N_LCSYM;
3196 letter = 'V';
3197 if (dbxout_common_check (decl, &offs) == NULLnullptr)
3198 addr = XEXP (XEXP (home, 0), 0)((((((home)->u.fld[0]).rt_rtx))->u.fld[0]).rt_rtx);
3199 else
3200 {
3201 addr = 0;
3202 number = offs;
3203 code = N_GSYM;
3204 }
3205 }
3206 else if (GET_CODE (home)((enum rtx_code) (home)->code) == CONCAT)
3207 {
3208 tree subtype;
3209
3210 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3211 for example), then there is no easy way to figure out
3212 what SUBTYPE should be. So, we give up. */
3213 if (TREE_CODE (type)((enum tree_code) (type)->base.code) != COMPLEX_TYPE)
3214 return 0;
3215
3216 subtype = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3216, __FUNCTION__))->typed.type)
;
3217
3218 /* If the variable's storage is in two parts,
3219 output each as a separate stab with a modified name. */
3220 if (WORDS_BIG_ENDIAN0)
3221 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0)(((home)->u.fld[0]).rt_rtx));
3222 else
3223 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0)(((home)->u.fld[0]).rt_rtx));
3224
3225 if (WORDS_BIG_ENDIAN0)
3226 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1)(((home)->u.fld[1]).rt_rtx));
3227 else
3228 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1)(((home)->u.fld[1]).rt_rtx));
3229 return 1;
3230 }
3231 else
3232 /* Address might be a MEM, when DECL is a variable-sized object.
3233 Or it might be const0_rtx, meaning previous passes
3234 want us to ignore this variable. */
3235 return 0;
3236
3237 /* Ok, start a symtab entry and output the variable name. */
3238 emit_pending_bincls_if_required ();
3239 FORCE_TEXT;
3240
3241#ifdef DBX_STATIC_BLOCK_START
3242 DBX_STATIC_BLOCK_START (asm_out_file, code);
3243#endif
3244
3245 dbxout_begin_complex_stabs_noforcetext ();
3246 dbxout_symbol_name (decl, suffix, letter);
3247 dbxout_type (type, 0);
3248 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3249
3250#ifdef DBX_STATIC_BLOCK_END
3251 DBX_STATIC_BLOCK_END (asm_out_file, code);
3252#endif
3253 return 1;
3254}
3255
3256/* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3257 Then output LETTER to indicate the kind of location the symbol has. */
3258
3259static void
3260dbxout_symbol_name (tree decl, const char *suffix, int letter)
3261{
3262 tree name;
3263
3264 if (DECL_CONTEXT (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3264, __FUNCTION__))->decl_minimal.context)
3265 && (TYPE_P (DECL_CONTEXT (decl))(tree_code_type[(int) (((enum tree_code) (((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3265, __FUNCTION__))->decl_minimal.context))->base.code
))] == tcc_type)
3266 || TREE_CODE (DECL_CONTEXT (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3266, __FUNCTION__))->decl_minimal.context))->base.code
)
== NAMESPACE_DECL))
3267 /* One slight hitch: if this is a VAR_DECL which is a class member
3268 or a namespace member, we must put out the mangled name instead of the
3269 DECL_NAME. Note also that static member (variable) names DO NOT begin
3270 with underscores in .stabs directives. */
3271 name = DECL_ASSEMBLER_NAME (decl)decl_assembler_name (decl);
3272 else
3273 /* ...but if we're function-local, we don't want to include the junk
3274 added by ASM_FORMAT_PRIVATE_NAME. */
3275 name = DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3275, __FUNCTION__))->decl_minimal.name)
;
3276
3277 if (name)
3278 stabstr_I (name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3278, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3278, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
3279 else
3280 stabstr_S ("(anon)")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("(anon)")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "(anon)", __len); __o->next_free += __len
; (void) 0; })
;
3281
3282 if (suffix)
3283 stabstr_S (suffix)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (suffix)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, suffix, __len); __o->next_free += __len
; (void) 0; })
;
3284 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
3285 if (letter)
3286 stabstr_C (letter)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (letter))); })
;
3287}
3288
3289
3290/* Output the common block name for DECL in a stabs.
3291
3292 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3293 around each group of symbols in the same .comm area. The N_GSYM stabs
3294 that are emitted only contain the offset in the common area. This routine
3295 emits the N_BCOMM and N_ECOMM stabs. */
3296
3297static void
3298dbxout_common_name (tree decl, const char *name, stab_code_type op)
3299{
3300 dbxout_begin_complex_stabs ();
3301 stabstr_S (name)__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen (name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, name, __len); __o->next_free += __len
; (void) 0; })
;
3302 dbxout_finish_complex_stabs (decl, op, NULL_RTX(rtx) 0, NULLnullptr, 0);
3303}
3304
3305/* Check decl to determine whether it is a VAR_DECL destined for storage in a
3306 common area. If it is, the return value will be a non-null string giving
3307 the name of the common storage block it will go into. If non-null, the
3308 value is the offset into the common block for that symbol's storage. */
3309
3310static const char *
3311dbxout_common_check (tree decl, int *value)
3312{
3313 rtx home;
3314 rtx sym_addr;
3315 const char *name = NULLnullptr;
3316
3317 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3318 it does not have a value (the offset into the common area), or if it
3319 is thread local (as opposed to global) then it isn't common, and shouldn't
3320 be handled as such.
3321
3322 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3323 for thread-local symbols. Can be handled via same mechanism as used
3324 in dwarf2out.c. */
3325 if (!VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL)
3326 || !TREE_STATIC (decl)((decl)->base.static_flag)
3327 || !DECL_HAS_VALUE_EXPR_P (decl)((tree_check3 ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3327, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2)
3328 || DECL_THREAD_LOCAL_P (decl)((((decl)->base.static_flag) || ((contains_struct_check ((
decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3328, __FUNCTION__))->decl_common.decl_flag_1)) &&
decl_tls_model (decl) >= TLS_MODEL_REAL)
3329 || !is_fortran ())
3330 return NULLnullptr;
3331
3332 home = DECL_RTL (decl)((contains_struct_check ((decl), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3332, __FUNCTION__))->decl_with_rtl.rtl ? (decl)->decl_with_rtl
.rtl : (make_decl_rtl (decl), (decl)->decl_with_rtl.rtl))
;
3333 if (home == NULL_RTX(rtx) 0 || GET_CODE (home)((enum rtx_code) (home)->code) != MEM)
3334 return NULLnullptr;
3335
3336 sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl)(decl_value_expr_lookup ((contains_struct_check ((decl), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3336, __FUNCTION__))))
);
3337 if (sym_addr == NULL_RTX(rtx) 0 || GET_CODE (sym_addr)((enum rtx_code) (sym_addr)->code) != MEM)
3338 return NULLnullptr;
3339
3340 sym_addr = XEXP (sym_addr, 0)(((sym_addr)->u.fld[0]).rt_rtx);
3341 if (GET_CODE (sym_addr)((enum rtx_code) (sym_addr)->code) == CONST)
3342 sym_addr = XEXP (sym_addr, 0)(((sym_addr)->u.fld[0]).rt_rtx);
3343 if ((GET_CODE (sym_addr)((enum rtx_code) (sym_addr)->code) == SYMBOL_REF || GET_CODE (sym_addr)((enum rtx_code) (sym_addr)->code) == PLUS)
3344 && DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3344, __FUNCTION__))->decl_common.initial)
== 0)
3345 {
3346
3347 /* We have a sym that will go into a common area, meaning that it
3348 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3349
3350 Determine name of common area this symbol will be an offset into,
3351 and offset into that area. Also retrieve the decl for the area
3352 that the symbol is offset into. */
3353 tree cdecl = NULLnullptr;
3354
3355 switch (GET_CODE (sym_addr)((enum rtx_code) (sym_addr)->code))
3356 {
3357 case PLUS:
3358 if (CONST_INT_P (XEXP (sym_addr, 0))(((enum rtx_code) ((((sym_addr)->u.fld[0]).rt_rtx))->code
) == CONST_INT)
)
3359 {
3360 name =
3361 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 1), 0)((((((sym_addr)->u.fld[1]).rt_rtx))->u.fld[0]).rt_str));
3362 *value = INTVAL (XEXP (sym_addr, 0))(((((sym_addr)->u.fld[0]).rt_rtx))->u.hwint[0]);
3363 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1))((__extension__ ({ __typeof (((((sym_addr)->u.fld[1]).rt_rtx
))) const _rtx = (((((sym_addr)->u.fld[1]).rt_rtx))); if (
((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3363, __FUNCTION__); _rtx; })->unchanging) ? nullptr : (
((((((sym_addr)->u.fld[1]).rt_rtx)))->u.fld[1]).rt_tree
))
;
3364 }
3365 else
3366 {
3367 name =
3368 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 0), 0)((((((sym_addr)->u.fld[0]).rt_rtx))->u.fld[0]).rt_str));
3369 *value = INTVAL (XEXP (sym_addr, 1))(((((sym_addr)->u.fld[1]).rt_rtx))->u.hwint[0]);
3370 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0))((__extension__ ({ __typeof (((((sym_addr)->u.fld[0]).rt_rtx
))) const _rtx = (((((sym_addr)->u.fld[0]).rt_rtx))); if (
((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3370, __FUNCTION__); _rtx; })->unchanging) ? nullptr : (
((((((sym_addr)->u.fld[0]).rt_rtx)))->u.fld[1]).rt_tree
))
;
3371 }
3372 break;
3373
3374 case SYMBOL_REF:
3375 name = targetm.strip_name_encoding (XSTR (sym_addr, 0)(((sym_addr)->u.fld[0]).rt_str));
3376 *value = 0;
3377 cdecl = SYMBOL_REF_DECL (sym_addr)((__extension__ ({ __typeof ((sym_addr)) const _rtx = ((sym_addr
)); if (((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3377, __FUNCTION__); _rtx; })->unchanging) ? nullptr : (
(((sym_addr))->u.fld[1]).rt_tree))
;
3378 break;
3379
3380 default:
3381 error ("common symbol debug info is not structured as "
3382 "symbol+offset");
3383 }
3384
3385 /* Check area common symbol is offset into. If this is not public, then
3386 it is not a symbol in a common block. It must be a .lcomm symbol, not
3387 a .comm symbol. */
3388 if (cdecl == NULLnullptr || !TREE_PUBLIC (cdecl)((cdecl)->base.public_flag))
3389 name = NULLnullptr;
3390 }
3391 else
3392 name = NULLnullptr;
3393
3394 return name;
3395}
3396
3397/* Output definitions of all the decls in a chain. Return nonzero if
3398 anything was output */
3399
3400int
3401dbxout_syms (tree syms)
3402{
3403 int result = 0;
3404 const char *comm_prev = NULLnullptr;
3405 tree syms_prev = NULLnullptr;
3406
3407 while (syms)
3408 {
3409 int temp, copen, cclos;
3410 const char *comm_new;
3411
3412 /* Check for common symbol, and then progression into a new/different
3413 block of common symbols. Emit closing/opening common bracket if
3414 necessary. */
3415 comm_new = dbxout_common_check (syms, &temp);
3416 copen = comm_new != NULLnullptr
3417 && (comm_prev == NULLnullptr || strcmp (comm_new, comm_prev));
3418 cclos = comm_prev != NULLnullptr
3419 && (comm_new == NULLnullptr || strcmp (comm_new, comm_prev));
3420 if (cclos)
3421 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3422 if (copen)
3423 {
3424 dbxout_common_name (syms, comm_new, N_BCOMM);
3425 syms_prev = syms;
3426 }
3427 comm_prev = comm_new;
3428
3429 result += dbxout_symbol (syms, 1);
3430 syms = DECL_CHAIN (syms)(((contains_struct_check (((contains_struct_check ((syms), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3430, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3430, __FUNCTION__))->common.chain))
;
3431 }
3432
3433 if (comm_prev != NULLnullptr)
3434 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3435
3436 return result;
3437}
3438
3439/* The following two functions output definitions of function parameters.
3440 Each parameter gets a definition locating it in the parameter list.
3441 Each parameter that is a register variable gets a second definition
3442 locating it in the register.
3443
3444 Printing or argument lists in gdb uses the definitions that
3445 locate in the parameter list. But reference to the variable in
3446 expressions uses preferentially the definition as a register. */
3447
3448/* Output definitions, referring to storage in the parmlist,
3449 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3450
3451void
3452dbxout_parms (tree parms)
3453{
3454 ++debug_nesting;
3455 emit_pending_bincls_if_required ();
3456 fixed_size_mode rtl_mode, type_mode;
3457
3458 for (; parms; parms = DECL_CHAIN (parms)(((contains_struct_check (((contains_struct_check ((parms), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3458, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3458, __FUNCTION__))->common.chain))
)
3459 if (DECL_NAME (parms)((contains_struct_check ((parms), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3459, __FUNCTION__))->decl_minimal.name)
3460 && TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3460, __FUNCTION__))->typed.type)
!= error_mark_nodeglobal_trees[TI_ERROR_MARK]
3461 && DECL_RTL_SET_P (parms)(((tree_contains_struct[(((enum tree_code) (parms)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((parms
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3461, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
3462 && DECL_INCOMING_RTL (parms)((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3462, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)
3463 /* We can't represent variable-sized types in this format. */
3464 && is_a <fixed_size_mode> (TYPE_MODE (TREE_TYPE (parms))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3464, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3464, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3464, __FUNCTION__))->typed.type)) : (((contains_struct_check
((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3464, __FUNCTION__))->typed.type))->type_common.mode)
, &type_mode)
3465 && is_a <fixed_size_mode> (GET_MODE (DECL_RTL (parms))((machine_mode) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3465, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->mode)
, &rtl_mode))
3466 {
3467 tree eff_type;
3468 char letter;
3469 stab_code_type code;
3470 int number;
3471
3472 /* Perform any necessary register eliminations on the parameter's rtl,
3473 so that the debugging output will be accurate. */
3474 DECL_INCOMING_RTL (parms)((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3474, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)
3475 = eliminate_regs (DECL_INCOMING_RTL (parms)((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3475, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)
, VOIDmode((void) 0, E_VOIDmode), NULL_RTX(rtx) 0);
3476 SET_DECL_RTL (parms,set_decl_rtl (parms, eliminate_regs (((contains_struct_check (
(parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3477, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
), ((void) 0, E_VOIDmode), (rtx) 0))
3477 eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX))set_decl_rtl (parms, eliminate_regs (((contains_struct_check (
(parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3477, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
), ((void) 0, E_VOIDmode), (rtx) 0))
;
3478#ifdef LEAF_REG_REMAP
3479 if (crtl(&x_rtl)->uses_only_leaf_regs)
3480 {
3481 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms)((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3481, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)
);
3482 leaf_renumber_regs_insn (DECL_RTL (parms)((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3482, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)
);
3483 }
3484#endif
3485
3486 if (PARM_PASSED_IN_MEMORY (parms)((((enum rtx_code) (((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3486, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
))->code) == MEM))
)
3487 {
3488 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0)(((((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3488, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
))->u.fld[0]).rt_rtx)
;
3489
3490 /* ??? Here we assume that the parm address is indexed
3491 off the frame pointer or arg pointer.
3492 If that is not true, we produce meaningless results,
3493 but do not crash. */
3494 if (GET_CODE (inrtl)((enum rtx_code) (inrtl)->code) == PLUS
3495 && CONST_INT_P (XEXP (inrtl, 1))(((enum rtx_code) ((((inrtl)->u.fld[1]).rt_rtx))->code)
== CONST_INT)
)
3496 number = INTVAL (XEXP (inrtl, 1))(((((inrtl)->u.fld[1]).rt_rtx))->u.hwint[0]);
3497 else
3498 number = 0;
3499
3500 code = N_PSYM;
3501 number = DEBUGGER_ARG_OFFSET (number, inrtl)(number + 0);
3502 letter = 'p';
3503
3504 /* It is quite tempting to use TREE_TYPE (parms) instead
3505 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3506 reports the actual type of the parameter, rather than
3507 the promoted type. This certainly makes GDB's life
3508 easier, at least for some ports. The change is a bad
3509 idea however, since GDB expects to be able access the
3510 type without performing any conversions. So for
3511 example, if we were passing a float to an unprototyped
3512 function, gcc will store a double on the stack, but if
3513 we emit a stab saying the type is a float, then gdb
3514 will only read in a single value, and this will produce
3515 an erroneous value. */
3516 eff_type = DECL_ARG_TYPE (parms)((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3516, __FUNCTION__, (PARM_DECL)))->decl_common.initial)
;
3517 }
3518 else if (REG_P (DECL_RTL (parms))(((enum rtx_code) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3518, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->code) == REG)
)
3519 {
3520 rtx best_rtl;
3521
3522 /* Parm passed in registers and lives in registers or nowhere. */
3523 code = DBX_REGPARM_STABS_CODEN_RSYM;
3524 letter = DBX_REGPARM_STABS_LETTER'P';
3525
3526 /* For parms passed in registers, it is better to use the
3527 declared type of the variable, not the type it arrived in. */
3528 eff_type = TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3528, __FUNCTION__))->typed.type)
;
3529
3530 /* If parm lives in a register, use that register; pretend
3531 the parm was passed there. It would be more consistent
3532 to describe the register where the parm was passed, but
3533 in practice that register usually holds something else.
3534 If the parm lives nowhere, use the register where it
3535 was passed. */
3536 if (REGNO (DECL_RTL (parms))(rhs_regno(((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3536, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)))
< FIRST_PSEUDO_REGISTER76)
3537 best_rtl = DECL_RTL (parms)((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3537, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)
;
3538 else if (GET_CODE (DECL_INCOMING_RTL (parms))((enum rtx_code) (((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3538, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
))->code)
== PARALLEL)
3539 best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0)((((((((((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3539, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
))->u.fld[0]).rt_rtvec))->elem[0]))->u.fld[0]).rt_rtx
)
;
3540 else
3541 best_rtl = DECL_INCOMING_RTL (parms)((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3541, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)
;
3542
3543 number = DBX_REGISTER_NUMBER (REGNO (best_rtl))(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
0) ? dbx64_register_map[(rhs_regno(best_rtl))] : svr4_dbx_register_map
[(rhs_regno(best_rtl))])
;
3544 }
3545 else if (MEM_P (DECL_RTL (parms))(((enum rtx_code) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3545, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->code) == MEM)
3546 && REG_P (XEXP (DECL_RTL (parms), 0))(((enum rtx_code) ((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3546, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx))->code) == REG)
3547 && REGNO (XEXP (DECL_RTL (parms), 0))(rhs_regno((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3547, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx)))
!= HARD_FRAME_POINTER_REGNUM6
3548 && REGNO (XEXP (DECL_RTL (parms), 0))(rhs_regno((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3548, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx)))
!= STACK_POINTER_REGNUM7
3549#if !HARD_FRAME_POINTER_IS_ARG_POINTER(6 == 16)
3550 && REGNO (XEXP (DECL_RTL (parms), 0))(rhs_regno((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3550, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx)))
!= ARG_POINTER_REGNUM16
3551#endif
3552 )
3553 {
3554 /* Parm was passed via invisible reference.
3555 That is, its address was passed in a register.
3556 Output it as if it lived in that register.
3557 The debugger will know from the type
3558 that it was actually passed by invisible reference. */
3559
3560 code = DBX_REGPARM_STABS_CODEN_RSYM;
3561
3562 /* GDB likes this marked with a special letter. */
3563 letter = (use_gnu_debug_info_extensionsglobal_options.x_use_gnu_debug_info_extensions
3564 ? 'a' : DBX_REGPARM_STABS_LETTER'P');
3565 eff_type = TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3565, __FUNCTION__))->typed.type)
;
3566
3567 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3568 If it is an unallocated pseudo-reg, then use the register where
3569 it was passed instead.
3570 ??? Why is DBX_REGISTER_NUMBER not used here? */
3571
3572 if (REGNO (XEXP (DECL_RTL (parms), 0))(rhs_regno((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3572, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx)))
< FIRST_PSEUDO_REGISTER76)
3573 number = REGNO (XEXP (DECL_RTL (parms), 0))(rhs_regno((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3573, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx)))
;
3574 else
3575 number = REGNO (DECL_INCOMING_RTL (parms))(rhs_regno(((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3575, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)))
;
3576 }
3577 else if (MEM_P (DECL_RTL (parms))(((enum rtx_code) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3577, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->code) == MEM)
3578 && MEM_P (XEXP (DECL_RTL (parms), 0))(((enum rtx_code) ((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3578, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx))->code) == MEM)
)
3579 {
3580 /* Parm was passed via invisible reference, with the reference
3581 living on the stack. DECL_RTL looks like
3582 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3583 could look like (MEM (MEM (REG))). */
3584
3585 code = N_PSYM;
3586 letter = 'v';
3587 eff_type = TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3587, __FUNCTION__))->typed.type)
;
3588
3589 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0))(((enum rtx_code) (((((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3589, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx))->u.fld[0]).rt_rtx))->code) ==
REG)
)
3590 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1))(((((((((((((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3590, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx))->u.fld[0]).rt_rtx))->u.fld[1]
).rt_rtx))->u.hwint[0])
;
3591 else
3592 number = 0;
3593
3594 number = DEBUGGER_ARG_OFFSET (number,(number + 0)
3595 XEXP (XEXP (DECL_RTL (parms), 0), 0))(number + 0);
3596 }
3597 else if (MEM_P (DECL_RTL (parms))(((enum rtx_code) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3597, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->code) == MEM)
3598 && XEXP (DECL_RTL (parms), 0)(((((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3598, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx)
!= const0_rtx(const_int_rtx[64])
3599 /* ??? A constant address for a parm can happen
3600 when the reg it lives in is equiv to a constant in memory.
3601 Should make this not happen, after 2.4. */
3602 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0))((rtx_class[(int) (((enum rtx_code) ((((((contains_struct_check
((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3602, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx))->code))]) == RTX_CONST_OBJ)
)
3603 {
3604 /* Parm was passed in registers but lives on the stack. */
3605
3606 code = N_PSYM;
3607 letter = 'p';
3608 eff_type = TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3608, __FUNCTION__))->typed.type)
;
3609
3610 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3611 in which case we want the value of that CONST_INT,
3612 or (MEM (REG ...)),
3613 in which case we use a value of zero. */
3614 if (!REG_P (XEXP (DECL_RTL (parms), 0))(((enum rtx_code) ((((((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3614, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx))->code) == REG)
)
3615 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))((((((((((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3615, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->u.fld[0]).rt_rtx))->u.fld[1]).rt_rtx))->u.hwint[
0])
;
3616 else
3617 number = 0;
3618
3619 /* Make a big endian correction if the mode of the type of the
3620 parameter is not the same as the mode of the rtl. */
3621 if (BYTES_BIG_ENDIAN0
3622 && type_mode != rtl_mode
3623 && GET_MODE_SIZE (type_mode) < UNITS_PER_WORD(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
0) ? 8 : 4)
)
3624 number += GET_MODE_SIZE (rtl_mode) - GET_MODE_SIZE (type_mode);
3625 }
3626 else
3627 /* ??? We don't know how to represent this argument. */
3628 continue;
3629
3630 dbxout_begin_complex_stabs ();
3631
3632 if (DECL_NAME (parms)((contains_struct_check ((parms), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3632, __FUNCTION__))->decl_minimal.name)
)
3633 {
3634 stabstr_I (DECL_NAME (parms))__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (((tree_check ((((contains_struct_check ((parms), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3634, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3634, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < __len
) _obstack_newchunk (__o, __len); memcpy (__o->next_free, (
(const char *) (tree_check ((((contains_struct_check ((parms)
, (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3634, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3634, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), __len); __o->next_free += __len; (void) 0; })
;
3635 stabstr_C (':')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (':'))); })
;
3636 }
3637 else
3638 stabstr_S ("(anon):")__extension__ ({ struct obstack *__o = (&stabstr_ob); size_t
__len = (strlen ("(anon):")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, "(anon):", __len); __o->next_free += __len
; (void) 0; })
;
3639 stabstr_C (letter)__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (letter))); })
;
3640 dbxout_type (eff_type, 0);
3641 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3642 }
3643 DBXOUT_DECR_NESTINGif (--debug_nesting == 0 && symbol_queue_index > 0
) { emit_pending_bincls_if_required (); debug_flush_symbol_queue
(); }
;
3644}
3645
3646/* Output definitions for the places where parms live during the function,
3647 when different from where they were passed, when the parms were passed
3648 in memory.
3649
3650 It is not useful to do this for parms passed in registers
3651 that live during the function in different registers, because it is
3652 impossible to look in the passed register for the passed value,
3653 so we use the within-the-function register to begin with.
3654
3655 PARMS is a chain of PARM_DECL nodes. */
3656
3657void
3658dbxout_reg_parms (tree parms)
3659{
3660 ++debug_nesting;
3661
3662 for (; parms; parms = DECL_CHAIN (parms)(((contains_struct_check (((contains_struct_check ((parms), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3662, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3662, __FUNCTION__))->common.chain))
)
3663 if (DECL_NAME (parms)((contains_struct_check ((parms), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3663, __FUNCTION__))->decl_minimal.name)
&& PARM_PASSED_IN_MEMORY (parms)((((enum rtx_code) (((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3663, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
))->code) == MEM))
)
3664 {
3665 /* Report parms that live in registers during the function
3666 but were passed in memory. */
3667 if (REG_P (DECL_RTL (parms))(((enum rtx_code) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3667, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->code) == REG)
3668 && REGNO (DECL_RTL (parms))(rhs_regno(((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3668, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)))
< FIRST_PSEUDO_REGISTER76)
3669 dbxout_symbol_location (parms, TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3669, __FUNCTION__))->typed.type)
,
3670 0, DECL_RTL (parms)((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3670, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)
);
3671 else if (GET_CODE (DECL_RTL (parms))((enum rtx_code) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3671, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->code)
== CONCAT)
3672 dbxout_symbol_location (parms, TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3672, __FUNCTION__))->typed.type)
,
3673 0, DECL_RTL (parms)((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3673, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)
);
3674 /* Report parms that live in memory but not where they were passed. */
3675 else if (MEM_P (DECL_RTL (parms))(((enum rtx_code) (((contains_struct_check ((parms), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3675, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
))->code) == MEM)
3676 && ! rtx_equal_p (DECL_RTL (parms)((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3676, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)
, DECL_INCOMING_RTL (parms)((tree_check ((parms), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3676, __FUNCTION__, (PARM_DECL)))->parm_decl.incoming_rtl
)
))
3677 dbxout_symbol_location (parms, TREE_TYPE (parms)((contains_struct_check ((parms), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3677, __FUNCTION__))->typed.type)
,
3678 0, DECL_RTL (parms)((contains_struct_check ((parms), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3678, __FUNCTION__))->decl_with_rtl.rtl ? (parms)->decl_with_rtl
.rtl : (make_decl_rtl (parms), (parms)->decl_with_rtl.rtl)
)
);
3679 }
3680 DBXOUT_DECR_NESTINGif (--debug_nesting == 0 && symbol_queue_index > 0
) { emit_pending_bincls_if_required (); debug_flush_symbol_queue
(); }
;
3681}
3682
3683/* Given a chain of ..._TYPE nodes (as come in a parameter list),
3684 output definitions of those names, in raw form */
3685
3686static void
3687dbxout_args (tree args)
3688{
3689 while (args)
3690 {
3691 stabstr_C (',')__extension__ ({ struct obstack *__o = (&stabstr_ob); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (','))); })
;
3692 dbxout_type (TREE_VALUE (args)((tree_check ((args), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3692, __FUNCTION__, (TREE_LIST)))->list.value)
, 0);
3693 args = TREE_CHAIN (args)((contains_struct_check ((args), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3693, __FUNCTION__))->common.chain)
;
3694 }
3695}
3696
3697#if defined (DBX_DEBUGGING_INFO1)
3698
3699/* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3700 BEGIN_LABEL is the name of the beginning of the function, which may
3701 be required. */
3702static void
3703dbx_output_lbrac (const char *label,
3704 const char *begin_label ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3705{
3706 dbxout_begin_stabn (N_LBRAC);
3707 if (DBX_BLOCKS_FUNCTION_RELATIVE1)
3708 dbxout_stab_value_label_diff (label, begin_label);
3709 else
3710 dbxout_stab_value_label (label);
3711}
3712
3713/* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3714 BEGIN_LABEL is the name of the beginning of the function, which may
3715 be required. */
3716static void
3717dbx_output_rbrac (const char *label,
3718 const char *begin_label ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3719{
3720 dbxout_begin_stabn (N_RBRAC);
3721 if (DBX_BLOCKS_FUNCTION_RELATIVE1)
3722 dbxout_stab_value_label_diff (label, begin_label);
3723 else
3724 dbxout_stab_value_label (label);
3725}
3726
3727/* Return true if at least one block among BLOCK, its children or siblings
3728 has TREE_USED, TREE_ASM_WRITTEN and BLOCK_IN_COLD_SECTION_P
3729 set. If there is none, clear TREE_USED bit on such blocks. */
3730
3731static bool
3732dbx_block_with_cold_children (tree block)
3733{
3734 bool ret = false;
3735 for (; block; block = BLOCK_CHAIN (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3735, __FUNCTION__, (BLOCK)))->block.chain)
)
3736 if (TREE_USED (block)((block)->base.used_flag) && TREE_ASM_WRITTEN (block)((block)->base.asm_written_flag))
3737 {
3738 bool children = dbx_block_with_cold_children (BLOCK_SUBBLOCKS (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3738, __FUNCTION__, (BLOCK)))->block.subblocks)
);
3739 if (BLOCK_IN_COLD_SECTION_P (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3739, __FUNCTION__, (BLOCK)))->base.u.bits.atomic_flag)
|| children)
3740 ret = true;
3741 else
3742 TREE_USED (block)((block)->base.used_flag) = false;
3743 }
3744 return ret;
3745}
3746
3747/* Output everything about a symbol block (a BLOCK node
3748 that represents a scope level),
3749 including recursive output of contained blocks.
3750
3751 BLOCK is the BLOCK node.
3752 DEPTH is its depth within containing symbol blocks.
3753 ARGS is usually zero; but for the outermost block of the
3754 body of a function, it is a chain of PARM_DECLs for the function parameters.
3755 We output definitions of all the register parms
3756 as if they were local variables of that block.
3757
3758 If -g1 was used, we count blocks just the same, but output nothing
3759 except for the outermost block.
3760
3761 Actually, BLOCK may be several blocks chained together.
3762 We handle them all in sequence.
3763
3764 Return true if we emitted any LBRAC/RBRAC. */
3765
3766static bool
3767dbxout_block (tree block, int depth, tree args, int parent_blocknum)
3768{
3769 bool ret = false;
3770 char begin_label[20];
3771 /* Reference current function start using LFBB. */
3772 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno)do { char *__p; (begin_label)[0] = '*'; (begin_label)[1] = '.'
; __p = stpcpy (&(begin_label)[2], "LFBB"); sprint_ul (__p
, (unsigned long) (scope_labelno)); } while (0)
;
3773
3774 /* If called for the second partition, ignore blocks that don't have
3775 any children in the second partition. */
3776 if (crtl(&x_rtl)->has_bb_partition && in_cold_section_p && depth == 0)
3777 dbx_block_with_cold_children (block);
3778
3779 for (; block; block = BLOCK_CHAIN (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3779, __FUNCTION__, (BLOCK)))->block.chain)
)
3780 {
3781 /* Ignore blocks never expanded or otherwise marked as real. */
3782 if (TREE_USED (block)((block)->base.used_flag) && TREE_ASM_WRITTEN (block)((block)->base.asm_written_flag))
3783 {
3784 int did_output;
3785 int blocknum = BLOCK_NUMBER (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3785, __FUNCTION__, (BLOCK)))->block.block_num)
;
3786 int this_parent = parent_blocknum;
3787
3788 /* In dbx format, the syms of a block come before the N_LBRAC.
3789 If nothing is output, we don't need the N_LBRAC, either. */
3790 did_output = 0;
3791 if (debug_info_levelglobal_options.x_debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3792 did_output = dbxout_syms (BLOCK_VARS (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3792, __FUNCTION__, (BLOCK)))->block.vars)
);
3793 if (args)
3794 dbxout_reg_parms (args);
3795
3796 /* Now output an N_LBRAC symbol to represent the beginning of
3797 the block. Use the block's tree-walk order to generate
3798 the assembler symbols LBBn and LBEn
3799 that final will define around the code in this block. */
3800 if (did_output
3801 && BLOCK_IN_COLD_SECTION_P (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3801, __FUNCTION__, (BLOCK)))->base.u.bits.atomic_flag)
== in_cold_section_p)
3802 {
3803 char buf[20];
3804 const char *scope_start;
3805
3806 ret = true;
3807 if (depth == 0)
3808 /* The outermost block doesn't get LBB labels; use
3809 the LFBB local symbol emitted by dbxout_begin_prologue. */
3810 scope_start = begin_label;
3811 else
3812 {
3813 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum)do { char *__p; (buf)[0] = '*'; (buf)[1] = '.'; __p = stpcpy (
&(buf)[2], "LBB"); sprint_ul (__p, (unsigned long) (blocknum
)); } while (0)
;
3814 scope_start = buf;
3815 this_parent = blocknum;
3816 }
3817
3818 dbx_output_lbrac (scope_start, begin_label);
3819 }
3820
3821 /* Output the subblocks. */
3822 bool children
3823 = dbxout_block (BLOCK_SUBBLOCKS (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3823, __FUNCTION__, (BLOCK)))->block.subblocks)
, depth + 1, NULL_TREE(tree) nullptr,
3824 this_parent);
3825 ret |= children;
3826
3827 /* Refer to the marker for the end of the block. */
3828 if (did_output
3829 && BLOCK_IN_COLD_SECTION_P (block)((tree_check ((block), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3829, __FUNCTION__, (BLOCK)))->base.u.bits.atomic_flag)
== in_cold_section_p)
3830 {
3831 char buf[100];
3832 if (depth == 0)
3833 /* The outermost block doesn't get LBE labels;
3834 use the "scope" label which will be emitted
3835 by dbxout_function_end. */
3836 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno)do { char *__p; (buf)[0] = '*'; (buf)[1] = '.'; __p = stpcpy (
&(buf)[2], "Lscope"); sprint_ul (__p, (unsigned long) (scope_labelno
)); } while (0)
;
3837 else
3838 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum)do { char *__p; (buf)[0] = '*'; (buf)[1] = '.'; __p = stpcpy (
&(buf)[2], "LBE"); sprint_ul (__p, (unsigned long) (blocknum
)); } while (0)
;
3839
3840 dbx_output_rbrac (buf, begin_label);
3841 }
3842 else if (did_output && !children)
3843 {
3844 /* If we emitted any vars and didn't output any LBRAC/RBRAC,
3845 either at this level or any lower level, we need to emit
3846 an empty LBRAC/RBRAC pair now. */
3847 char buf[30];
3848 const char *scope_start;
3849
3850 ret = true;
3851 if (parent_blocknum == -1)
3852 scope_start = begin_label;
3853 else
3854 {
3855 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", parent_blocknum)do { char *__p; (buf)[0] = '*'; (buf)[1] = '.'; __p = stpcpy (
&(buf)[2], "LBB"); sprint_ul (__p, (unsigned long) (parent_blocknum
)); } while (0)
;
3856 scope_start = buf;
3857 }
3858
3859 dbx_output_lbrac (scope_start, begin_label);
3860 dbx_output_rbrac (scope_start, begin_label);
3861 }
3862 }
3863 }
3864 return ret;
3865}
3866
3867/* Output the information about a function and its arguments and result.
3868 Usually this follows the function's code,
3869 but on some systems, it comes before. */
3870
3871static void
3872dbxout_begin_function (tree decl)
3873{
3874 int saved_tree_used1;
3875
3876 saved_tree_used1 = TREE_USED (decl)((decl)->base.used_flag);
3877 TREE_USED (decl)((decl)->base.used_flag) = 1;
3878 if (DECL_NAME (DECL_RESULT (decl))((contains_struct_check ((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3878, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3878, __FUNCTION__))->decl_minimal.name)
!= 0)
3879 {
3880 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl))((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3880, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
))->base.used_flag)
;
3881 TREE_USED (DECL_RESULT (decl))((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3881, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
))->base.used_flag)
= 1;
3882 dbxout_symbol (decl, 0);
3883 TREE_USED (DECL_RESULT (decl))((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3883, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
))->base.used_flag)
= saved_tree_used2;
3884 }
3885 else
3886 dbxout_symbol (decl, 0);
3887 TREE_USED (decl)((decl)->base.used_flag) = saved_tree_used1;
3888
3889 dbxout_parms (DECL_ARGUMENTS (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3889, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
);
3890 if (DECL_NAME (DECL_RESULT (decl))((contains_struct_check ((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3890, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3890, __FUNCTION__))->decl_minimal.name)
!= 0)
3891 dbxout_symbol (DECL_RESULT (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/dbxout.c"
, 3891, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
, 1);
3892}
3893#endif /* DBX_DEBUGGING_INFO */
3894
3895#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3896
3897/* Record an element in the table of global destructors. SYMBOL is
3898 a SYMBOL_REF of the function to be called; PRIORITY is a number
3899 between 0 and MAX_INIT_PRIORITY. */
3900
3901void
3902default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
3903 int priority ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3904{
3905#if defined DBX_DEBUGGING_INFO1 || defined XCOFF_DEBUGGING_INFO
3906 /* Tell GNU LD that this is part of the static destructor set.
3907 This will work for any system that uses stabs, most usefully
3908 aout systems. */
3909 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3910 dbxout_stab_value_label (XSTR (symbol, 0)(((symbol)->u.fld[0]).rt_str));
3911#else
3912 sorry ("global destructors not supported on this target");
3913#endif
3914}
3915
3916/* Likewise for global constructors. */
3917
3918void
3919default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
3920 int priority ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3921{
3922#if defined DBX_DEBUGGING_INFO1 || defined XCOFF_DEBUGGING_INFO
3923 /* Tell GNU LD that this is part of the static destructor set.
3924 This will work for any system that uses stabs, most usefully
3925 aout systems. */
3926 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3927 dbxout_stab_value_label (XSTR (symbol, 0)(((symbol)->u.fld[0]).rt_str));
3928#else
3929 sorry ("global constructors not supported on this target");
3930#endif
3931}
3932
3933#include "gt-dbxout.h"