OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [xcoffout.c] - Blame information for rev 856

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Output xcoff-format symbol table information from GNU compiler.
2
   Copyright (C) 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004,
3
   2007, 2008  Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
/* Output xcoff-format symbol table data.  The main functionality is contained
22
   in dbxout.c.  This file implements the sdbout-like parts of the xcoff
23
   interface.  Many functions are very similar to their counterparts in
24
   sdbout.c.  */
25
 
26
#include "config.h"
27
#include "system.h"
28
#include "coretypes.h"
29
#include "tm.h"
30
#include "tree.h"
31
#include "rtl.h"
32
#include "flags.h"
33
#include "toplev.h"
34
#include "output.h"
35
#include "ggc.h"
36
#include "target.h"
37
#include "debug.h"
38
 
39
#ifdef XCOFF_DEBUGGING_INFO
40
 
41
/* This defines the C_* storage classes.  */
42
#include "xcoff.h"
43
#include "xcoffout.h"
44
#include "dbxout.h"
45
#include "gstab.h"
46
 
47
/* Line number of beginning of current function, minus one.
48
   Negative means not in a function or not using xcoff.  */
49
 
50
static int xcoff_begin_function_line = -1;
51
static int xcoff_inlining = 0;
52
 
53
/* Name of the current include file.  */
54
 
55
const char *xcoff_current_include_file;
56
 
57
/* Name of the current function file.  This is the file the `.bf' is
58
   emitted from.  In case a line is emitted from a different file,
59
   (by including that file of course), then the line number will be
60
   absolute.  */
61
 
62
static const char *xcoff_current_function_file;
63
 
64
/* Names of bss and data sections.  These should be unique names for each
65
   compilation unit.  */
66
 
67
char *xcoff_bss_section_name;
68
char *xcoff_private_data_section_name;
69
char *xcoff_read_only_section_name;
70
 
71
/* Last source file name mentioned in a NOTE insn.  */
72
 
73
const char *xcoff_lastfile;
74
 
75
/* Macro definitions used below.  */
76
 
77
#define ABS_OR_RELATIVE_LINENO(LINENO)          \
78
((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
79
 
80
/* Output source line numbers via ".line".  */
81
#define ASM_OUTPUT_LINE(FILE,LINENUM)                                      \
82
  do                                                                       \
83
    {                                                                      \
84
      if (xcoff_begin_function_line >= 0)                                   \
85
        fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
86
    }                                                                      \
87
  while (0)
88
 
89
#define ASM_OUTPUT_LFB(FILE,LINENUM) \
90
{                                               \
91
  if (xcoff_begin_function_line == -1)          \
92
    {                                           \
93
      xcoff_begin_function_line = (LINENUM) - 1;\
94
      fprintf (FILE, "\t.bf\t%d\n", (LINENUM)); \
95
    }                                           \
96
  xcoff_current_function_file                   \
97
    = (xcoff_current_include_file               \
98
       ? xcoff_current_include_file : main_input_filename); \
99
}
100
 
101
#define ASM_OUTPUT_LFE(FILE,LINENUM)            \
102
  do                                            \
103
    {                                           \
104
      fprintf (FILE, "\t.ef\t%d\n", (LINENUM)); \
105
      xcoff_begin_function_line = -1;           \
106
    }                                           \
107
  while (0)
108
 
109
#define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
110
  fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
111
 
112
#define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
113
  fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
114
 
115
static void xcoffout_block (tree, int, tree);
116
static void xcoffout_source_file (FILE *, const char *, int);
117
 
118
/* Support routines for XCOFF debugging info.  */
119
 
120
struct xcoff_type_number
121
{
122
  const char *name;
123
  int number;
124
};
125
static const struct xcoff_type_number xcoff_type_numbers[] = {
126
  { "int", -1 },
127
  { "char", -2 },
128
  { "short int", -3 },
129
  { "long int", -4 },  /* fiddled to -31 if 64 bits */
130
  { "unsigned char", -5 },
131
  { "signed char", -6 },
132
  { "short unsigned int", -7 },
133
  { "unsigned int", -8 },
134
  /* No such type "unsigned".  */
135
  { "long unsigned int", -10 }, /* fiddled to -32 if 64 bits */
136
  { "void", -11 },
137
  { "float", -12 },
138
  { "double", -13 },
139
  { "long double", -14 },
140
  /* Pascal and Fortran types run from -15 to -29.  */
141
  { "wchar", -30 },  /* XXX Should be "wchar_t" ? */
142
  { "long long int", -31 },
143
  { "long long unsigned int", -32 },
144
  /* Additional Fortran types run from -33 to -37.  */
145
 
146
  /* ??? Should also handle built-in C++ and Obj-C types.  There perhaps
147
     aren't any that C doesn't already have.  */
148
};
149
 
150
/* Returns an XCOFF fundamental type number for DECL (assumed to be a
151
   TYPE_DECL), or 0 if dbxout.c should assign a type number normally.  */
152
int
153
xcoff_assign_fundamental_type_number (tree decl)
154
{
155
  const char *name;
156
  size_t i;
157
 
158
  /* Do not waste time searching the list for non-intrinsic types.  */
159
  if (DECL_NAME (decl) == 0 || ! DECL_IS_BUILTIN (decl))
160
    return 0;
161
 
162
  name = IDENTIFIER_POINTER (DECL_NAME (decl));
163
 
164
  /* Linear search, blech, but the list is too small to bother
165
     doing anything else.  */
166
  for (i = 0; i < ARRAY_SIZE (xcoff_type_numbers); i++)
167
    if (!strcmp (xcoff_type_numbers[i].name, name))
168
      goto found;
169
  return 0;
170
 
171
 found:
172
  /* -4 and -10 should be replaced with -31 and -32, respectively,
173
     when used for a 64-bit type.  */
174
  if (int_size_in_bytes (TREE_TYPE (decl)) == 8)
175
    {
176
      if (xcoff_type_numbers[i].number == -4)
177
        return -31;
178
      if (xcoff_type_numbers[i].number == -10)
179
        return -32;
180
    }
181
  return xcoff_type_numbers[i].number;
182
}
183
 
184
/* Print an error message for unrecognized stab codes.  */
185
 
186
#define UNKNOWN_STAB(STR)       \
187
  internal_error ("no sclass for %s stab (0x%x)", STR, stab)
188
 
189
/* Conversion routine from BSD stabs to AIX storage classes.  */
190
 
191
int
192
stab_to_sclass (int stab)
193
{
194
  switch (stab)
195
    {
196
    case N_GSYM:
197
      return C_GSYM;
198
 
199
    case N_FNAME:
200
      UNKNOWN_STAB ("N_FNAME");
201
 
202
    case N_FUN:
203
      return C_FUN;
204
 
205
    case N_STSYM:
206
    case N_LCSYM:
207
      return C_STSYM;
208
 
209
    case N_MAIN:
210
      UNKNOWN_STAB ("N_MAIN");
211
 
212
    case N_RSYM:
213
      return C_RSYM;
214
 
215
    case N_SSYM:
216
      UNKNOWN_STAB ("N_SSYM");
217
 
218
    case N_RPSYM:
219
      return C_RPSYM;
220
 
221
    case N_PSYM:
222
      return C_PSYM;
223
    case N_LSYM:
224
      return C_LSYM;
225
    case N_DECL:
226
      return C_DECL;
227
    case N_ENTRY:
228
      return C_ENTRY;
229
 
230
    case N_SO:
231
      UNKNOWN_STAB ("N_SO");
232
 
233
    case N_SOL:
234
      UNKNOWN_STAB ("N_SOL");
235
 
236
    case N_SLINE:
237
      UNKNOWN_STAB ("N_SLINE");
238
 
239
    case N_DSLINE:
240
      UNKNOWN_STAB ("N_DSLINE");
241
 
242
    case N_BSLINE:
243
      UNKNOWN_STAB ("N_BSLINE");
244
 
245
    case N_BINCL:
246
      UNKNOWN_STAB ("N_BINCL");
247
 
248
    case N_EINCL:
249
      UNKNOWN_STAB ("N_EINCL");
250
 
251
    case N_EXCL:
252
      UNKNOWN_STAB ("N_EXCL");
253
 
254
    case N_LBRAC:
255
      UNKNOWN_STAB ("N_LBRAC");
256
 
257
    case N_RBRAC:
258
      UNKNOWN_STAB ("N_RBRAC");
259
 
260
    case N_BCOMM:
261
      return C_BCOMM;
262
    case N_ECOMM:
263
      return C_ECOMM;
264
    case N_ECOML:
265
      return C_ECOML;
266
 
267
    case N_LENG:
268
      UNKNOWN_STAB ("N_LENG");
269
 
270
    case N_PC:
271
      UNKNOWN_STAB ("N_PC");
272
 
273
    case N_M2C:
274
      UNKNOWN_STAB ("N_M2C");
275
 
276
    case N_SCOPE:
277
      UNKNOWN_STAB ("N_SCOPE");
278
 
279
    case N_CATCH:
280
      UNKNOWN_STAB ("N_CATCH");
281
 
282
    case N_OPT:
283
      UNKNOWN_STAB ("N_OPT");
284
 
285
    default:
286
      UNKNOWN_STAB ("?");
287
    }
288
}
289
 
290
/* Output debugging info to FILE to switch to sourcefile FILENAME.
291
   INLINE_P is true if this is from an inlined function.  */
292
 
293
static void
294
xcoffout_source_file (FILE *file, const char *filename, int inline_p)
295
{
296
  if (filename
297
      && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
298
          || (inline_p && ! xcoff_inlining)
299
          || (! inline_p && xcoff_inlining)))
300
    {
301
      if (xcoff_current_include_file)
302
        {
303
          fprintf (file, "\t.ei\t");
304
          output_quoted_string (file,
305
              remap_debug_filename (xcoff_current_include_file));
306
          fprintf (file, "\n");
307
          xcoff_current_include_file = NULL;
308
        }
309
      xcoff_inlining = inline_p;
310
      if (strcmp (main_input_filename, filename) || inline_p)
311
        {
312
          fprintf (file, "\t.bi\t");
313
          output_quoted_string (file, remap_debug_filename (filename));
314
          fprintf (file, "\n");
315
          xcoff_current_include_file = filename;
316
        }
317
      xcoff_lastfile = filename;
318
    }
319
}
320
 
321
/* Output a line number symbol entry for location (FILENAME, LINE).  */
322
 
323
void
324
xcoffout_source_line (unsigned int line, const char *filename,
325
                      int discriminator ATTRIBUTE_UNUSED,
326
                      bool is_stmt ATTRIBUTE_UNUSED)
327
{
328
  bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
329
                   || (int) line < xcoff_begin_function_line);
330
 
331
  xcoffout_source_file (asm_out_file, filename, inline_p);
332
 
333
  ASM_OUTPUT_LINE (asm_out_file, line);
334
}
335
 
336
/* Output the symbols defined in block number DO_BLOCK.
337
 
338
   This function works by walking the tree structure of blocks,
339
   counting blocks until it finds the desired block.  */
340
 
341
static int do_block = 0;
342
 
343
static void
344
xcoffout_block (tree block, int depth, tree args)
345
{
346
  while (block)
347
    {
348
      /* Ignore blocks never expanded or otherwise marked as real.  */
349
      if (TREE_USED (block))
350
        {
351
          /* When we reach the specified block, output its symbols.  */
352
          if (BLOCK_NUMBER (block) == do_block)
353
            {
354
              /* Output the syms of the block.  */
355
              if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
356
                dbxout_syms (BLOCK_VARS (block));
357
              if (args)
358
                dbxout_reg_parms (args);
359
 
360
              /* We are now done with the block.  Don't go to inner blocks.  */
361
              return;
362
            }
363
          /* If we are past the specified block, stop the scan.  */
364
          else if (BLOCK_NUMBER (block) >= do_block)
365
            return;
366
 
367
          /* Output the subblocks.  */
368
          xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
369
        }
370
      block = BLOCK_CHAIN (block);
371
    }
372
}
373
 
374
/* Describe the beginning of an internal block within a function.
375
   Also output descriptions of variables defined in this block.
376
 
377
   N is the number of the block, by order of beginning, counting from 1,
378
   and not counting the outermost (function top-level) block.
379
   The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
380
   if the count starts at 0 for the outermost one.  */
381
 
382
void
383
xcoffout_begin_block (unsigned int line, unsigned int n)
384
{
385
  tree decl = current_function_decl;
386
 
387
  /* The IBM AIX compiler does not emit a .bb for the function level scope,
388
     so we avoid it here also.  */
389
  if (n != 1)
390
    ASM_OUTPUT_LBB (asm_out_file, line, n);
391
 
392
  do_block = n;
393
  xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
394
}
395
 
396
/* Describe the end line-number of an internal block within a function.  */
397
 
398
void
399
xcoffout_end_block (unsigned int line, unsigned int n)
400
{
401
  if (n != 1)
402
    ASM_OUTPUT_LBE (asm_out_file, line, n);
403
}
404
 
405
/* Called at beginning of function (before prologue).
406
   Declare function as needed for debugging.  */
407
 
408
void
409
xcoffout_declare_function (FILE *file, tree decl, const char *name)
410
{
411
  size_t len;
412
 
413
  if (*name == '*')
414
    name++;
415
  len = strlen (name);
416
  if (name[len - 1] == ']')
417
    {
418
      char *n = XALLOCAVEC (char, len - 3);
419
      memcpy (n, name, len - 4);
420
      n[len - 4] = '\0';
421
      name = n;
422
    }
423
 
424
  /* Any pending .bi or .ei must occur before the .function pseudo op.
425
     Otherwise debuggers will think that the function is in the previous
426
     file and/or at the wrong line number.  */
427
  xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
428
  dbxout_symbol (decl, 0);
429
 
430
  /* .function NAME, TOP, MAPPING, TYPE, SIZE
431
     16 and 044 are placeholders for backwards compatibility */
432
  fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
433
           name, name, name, name);
434
}
435
 
436
/* Called at beginning of function body (at start of prologue).
437
   Record the function's starting line number, so we can output
438
   relative line numbers for the other lines.
439
   Record the file name that this function is contained in.  */
440
 
441
void
442
xcoffout_begin_prologue (unsigned int line,
443
                         const char *file ATTRIBUTE_UNUSED)
444
{
445
  ASM_OUTPUT_LFB (asm_out_file, line);
446
  dbxout_parms (DECL_ARGUMENTS (current_function_decl));
447
 
448
  /* Emit the symbols for the outermost BLOCK's variables.  sdbout.c does this
449
     in sdbout_begin_block, but there is no guarantee that there will be any
450
     inner block 1, so we must do it here.  This gives a result similar to
451
     dbxout, so it does make some sense.  */
452
  do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
453
  xcoffout_block (DECL_INITIAL (current_function_decl), 0,
454
                  DECL_ARGUMENTS (current_function_decl));
455
 
456
  ASM_OUTPUT_LINE (asm_out_file, line);
457
}
458
 
459
/* Called at end of function (before epilogue).
460
   Describe end of outermost block.  */
461
 
462
void
463
xcoffout_end_function (unsigned int last_linenum)
464
{
465
  ASM_OUTPUT_LFE (asm_out_file, last_linenum);
466
}
467
 
468
/* Output xcoff info for the absolute end of a function.
469
   Called after the epilogue is output.  */
470
 
471
void
472
xcoffout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
473
                       const char *file ATTRIBUTE_UNUSED)
474
{
475
  /* We need to pass the correct function size to .function, otherwise,
476
     the xas assembler can't figure out the correct size for the function
477
     aux entry.  So, we emit a label after the last instruction which can
478
     be used by the .function pseudo op to calculate the function size.  */
479
 
480
  const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
481
  if (*fname == '*')
482
    ++fname;
483
  fprintf (asm_out_file, "FE..");
484
  ASM_OUTPUT_LABEL (asm_out_file, fname);
485
}
486
#endif /* XCOFF_DEBUGGING_INFO */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.