OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [xcoffout.c] - Blame information for rev 154

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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