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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [dwarf2asm.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Dwarf2 assembler output helper routines.
2
   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3
   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
 
22
#include "config.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "flags.h"
27
#include "tree.h"
28
#include "rtl.h"
29
#include "output.h"
30
#include "target.h"
31
#include "dwarf2asm.h"
32
#include "dwarf2.h"
33
#include "splay-tree.h"
34
#include "ggc.h"
35
#include "tm_p.h"
36
 
37
 
38
/* How to start an assembler comment.  */
39
#ifndef ASM_COMMENT_START
40
#define ASM_COMMENT_START ";#"
41
#endif
42
 
43
 
44
/* Output an unaligned integer with the given value and size.  Prefer not
45
   to print a newline, since the caller may want to add a comment.  */
46
 
47
void
48
dw2_assemble_integer (int size, rtx x)
49
{
50
  const char *op = integer_asm_op (size, FALSE);
51
 
52
  if (op)
53
    {
54
      fputs (op, asm_out_file);
55
      if (CONST_INT_P (x))
56
        fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX,
57
                 (unsigned HOST_WIDE_INT) INTVAL (x));
58
      else
59
        output_addr_const (asm_out_file, x);
60
    }
61
  else
62
    assemble_integer (x, size, BITS_PER_UNIT, 1);
63
}
64
 
65
 
66
/* Output a value of a given size in target byte order.  */
67
 
68
void
69
dw2_asm_output_data_raw (int size, unsigned HOST_WIDE_INT value)
70
{
71
  unsigned char bytes[8];
72
  int i;
73
 
74
  for (i = 0; i < 8; ++i)
75
    {
76
      bytes[i] = value & 0xff;
77
      value >>= 8;
78
    }
79
 
80
  if (BYTES_BIG_ENDIAN)
81
    {
82
      for (i = size - 1; i > 0; --i)
83
        fprintf (asm_out_file, "0x%x,", bytes[i]);
84
      fprintf (asm_out_file, "0x%x", bytes[0]);
85
    }
86
  else
87
    {
88
      for (i = 0; i < size - 1; ++i)
89
        fprintf (asm_out_file, "0x%x,", bytes[i]);
90
      fprintf (asm_out_file, "0x%x", bytes[i]);
91
    }
92
}
93
 
94
/* Output an immediate constant in a given SIZE in bytes.  */
95
 
96
void
97
dw2_asm_output_data (int size, unsigned HOST_WIDE_INT value,
98
                     const char *comment, ...)
99
{
100
  va_list ap;
101
  const char *op = integer_asm_op (size, FALSE);
102
 
103
  va_start (ap, comment);
104
 
105
  if (size * 8 < HOST_BITS_PER_WIDE_INT)
106
    value &= ~(~(unsigned HOST_WIDE_INT) 0 << (size * 8));
107
 
108
  if (op)
109
    fprintf (asm_out_file, "%s" HOST_WIDE_INT_PRINT_HEX, op, value);
110
  else
111
    assemble_integer (GEN_INT (value), size, BITS_PER_UNIT, 1);
112
 
113
  if (flag_debug_asm && comment)
114
    {
115
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
116
      vfprintf (asm_out_file, comment, ap);
117
    }
118
  fputc ('\n', asm_out_file);
119
 
120
  va_end (ap);
121
}
122
 
123
/* Output the difference between two symbols in a given size.  */
124
/* ??? There appear to be assemblers that do not like such
125
   subtraction, but do support ASM_SET_OP.  It's unfortunately
126
   impossible to do here, since the ASM_SET_OP for the difference
127
   symbol must appear after both symbols are defined.  */
128
 
129
void
130
dw2_asm_output_delta (int size, const char *lab1, const char *lab2,
131
                      const char *comment, ...)
132
{
133
  va_list ap;
134
 
135
  va_start (ap, comment);
136
 
137
#ifdef ASM_OUTPUT_DWARF_DELTA
138
  ASM_OUTPUT_DWARF_DELTA (asm_out_file, size, lab1, lab2);
139
#else
140
  dw2_assemble_integer (size,
141
                        gen_rtx_MINUS (Pmode,
142
                                       gen_rtx_SYMBOL_REF (Pmode, lab1),
143
                                       gen_rtx_SYMBOL_REF (Pmode, lab2)));
144
#endif
145
  if (flag_debug_asm && comment)
146
    {
147
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
148
      vfprintf (asm_out_file, comment, ap);
149
    }
150
  fputc ('\n', asm_out_file);
151
 
152
  va_end (ap);
153
}
154
 
155
/* Output a section-relative reference to a LABEL, which was placed in
156
   BASE.  In general this can only be done for debugging symbols.
157
   E.g. on most targets with the GNU linker, this is accomplished with
158
   a direct reference and the knowledge that the debugging section
159
   will be placed at VMA 0.  Some targets have special relocations for
160
   this that we must use.  */
161
 
162
void
163
dw2_asm_output_offset (int size, const char *label,
164
                       section *base ATTRIBUTE_UNUSED,
165
                       const char *comment, ...)
166
{
167
  va_list ap;
168
 
169
  va_start (ap, comment);
170
 
171
#ifdef ASM_OUTPUT_DWARF_OFFSET
172
  ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label, base);
173
#else
174
  dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
175
#endif
176
 
177
  if (flag_debug_asm && comment)
178
    {
179
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
180
      vfprintf (asm_out_file, comment, ap);
181
    }
182
  fputc ('\n', asm_out_file);
183
 
184
  va_end (ap);
185
}
186
 
187
#if 0
188
 
189
/* Output a self-relative reference to a label, possibly in a
190
   different section or object file.  */
191
 
192
void
193
dw2_asm_output_pcrel (int size ATTRIBUTE_UNUSED,
194
                      const char *label ATTRIBUTE_UNUSED,
195
                      const char *comment, ...)
196
{
197
  va_list ap;
198
 
199
  va_start (ap, comment);
200
 
201
#ifdef ASM_OUTPUT_DWARF_PCREL
202
  ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
203
#else
204
  dw2_assemble_integer (size,
205
                        gen_rtx_MINUS (Pmode,
206
                                       gen_rtx_SYMBOL_REF (Pmode, label),
207
                                       pc_rtx));
208
#endif
209
 
210
  if (flag_debug_asm && comment)
211
    {
212
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
213
      vfprintf (asm_out_file, comment, ap);
214
    }
215
  fputc ('\n', asm_out_file);
216
 
217
  va_end (ap);
218
}
219
#endif /* 0 */
220
 
221
/* Output an absolute reference to a label.  */
222
 
223
void
224
dw2_asm_output_addr (int size, const char *label,
225
                     const char *comment, ...)
226
{
227
  va_list ap;
228
 
229
  va_start (ap, comment);
230
 
231
  dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
232
 
233
  if (flag_debug_asm && comment)
234
    {
235
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
236
      vfprintf (asm_out_file, comment, ap);
237
    }
238
  fputc ('\n', asm_out_file);
239
 
240
  va_end (ap);
241
}
242
 
243
/* Similar, but use an RTX expression instead of a text label.  */
244
 
245
void
246
dw2_asm_output_addr_rtx (int size, rtx addr,
247
                         const char *comment, ...)
248
{
249
  va_list ap;
250
 
251
  va_start (ap, comment);
252
 
253
  dw2_assemble_integer (size, addr);
254
 
255
  if (flag_debug_asm && comment)
256
    {
257
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
258
      vfprintf (asm_out_file, comment, ap);
259
    }
260
  fputc ('\n', asm_out_file);
261
 
262
  va_end (ap);
263
}
264
 
265
/* Output the first ORIG_LEN characters of STR as a string.
266
   If ORIG_LEN is equal to -1, ignore this parameter and output
267
   the entire STR instead.
268
   If COMMENT is not NULL and comments in the debug information
269
   have been requested by the user, append the given COMMENT
270
   to the generated output.  */
271
 
272
void
273
dw2_asm_output_nstring (const char *str, size_t orig_len,
274
                        const char *comment, ...)
275
{
276
  size_t i, len;
277
  va_list ap;
278
 
279
  va_start (ap, comment);
280
 
281
  len = orig_len;
282
 
283
  if (len == (size_t) -1)
284
    len = strlen (str);
285
 
286
  if (flag_debug_asm && comment)
287
    {
288
      fputs ("\t.ascii \"", asm_out_file);
289
      for (i = 0; i < len; i++)
290
        {
291
          int c = str[i];
292
          if (c == '\"' || c == '\\')
293
            fputc ('\\', asm_out_file);
294
          if (ISPRINT(c))
295
            fputc (c, asm_out_file);
296
          else
297
            fprintf (asm_out_file, "\\%o", c);
298
        }
299
      fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
300
      vfprintf (asm_out_file, comment, ap);
301
      fputc ('\n', asm_out_file);
302
    }
303
  else
304
    {
305
      /* If an explicit length was given, we can't assume there
306
         is a null termination in the string buffer.  */
307
      if (orig_len == (size_t) -1)
308
        len += 1;
309
      ASM_OUTPUT_ASCII (asm_out_file, str, len);
310
      if (orig_len != (size_t) -1)
311
        assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
312
    }
313
 
314
  va_end (ap);
315
}
316
 
317
 
318
/* Return the size of an unsigned LEB128 quantity.  */
319
 
320
int
321
size_of_uleb128 (unsigned HOST_WIDE_INT value)
322
{
323
  int size = 0;
324
 
325
  do
326
    {
327
      value >>= 7;
328
      size += 1;
329
    }
330
  while (value != 0);
331
 
332
  return size;
333
}
334
 
335
/* Return the size of a signed LEB128 quantity.  */
336
 
337
int
338
size_of_sleb128 (HOST_WIDE_INT value)
339
{
340
  int size = 0, byte;
341
 
342
  do
343
    {
344
      byte = (value & 0x7f);
345
      value >>= 7;
346
      size += 1;
347
    }
348
  while (!((value == 0 && (byte & 0x40) == 0)
349
           || (value == -1 && (byte & 0x40) != 0)));
350
 
351
  return size;
352
}
353
 
354
/* Given an encoding, return the number of bytes the format occupies.
355
   This is only defined for fixed-size encodings, and so does not
356
   include leb128.  */
357
 
358
int
359
size_of_encoded_value (int encoding)
360
{
361
  if (encoding == DW_EH_PE_omit)
362
    return 0;
363
 
364
  switch (encoding & 0x07)
365
    {
366
    case DW_EH_PE_absptr:
367
      return POINTER_SIZE / BITS_PER_UNIT;
368
    case DW_EH_PE_udata2:
369
      return 2;
370
    case DW_EH_PE_udata4:
371
      return 4;
372
    case DW_EH_PE_udata8:
373
      return 8;
374
    default:
375
      gcc_unreachable ();
376
    }
377
}
378
 
379
/* Yield a name for a given pointer encoding.  */
380
 
381
const char *
382
eh_data_format_name (int format)
383
{
384
#if HAVE_DESIGNATED_INITIALIZERS
385
#define S(p, v)         [p] = v,
386
#else
387
#define S(p, v)         case p: return v;
388
#endif
389
 
390
#if HAVE_DESIGNATED_INITIALIZERS
391
  __extension__ static const char * const format_names[256] = {
392
#else
393
  switch (format) {
394
#endif
395
 
396
  S(DW_EH_PE_absptr, "absolute")
397
  S(DW_EH_PE_omit, "omit")
398
  S(DW_EH_PE_aligned, "aligned absolute")
399
 
400
  S(DW_EH_PE_uleb128, "uleb128")
401
  S(DW_EH_PE_udata2, "udata2")
402
  S(DW_EH_PE_udata4, "udata4")
403
  S(DW_EH_PE_udata8, "udata8")
404
  S(DW_EH_PE_sleb128, "sleb128")
405
  S(DW_EH_PE_sdata2, "sdata2")
406
  S(DW_EH_PE_sdata4, "sdata4")
407
  S(DW_EH_PE_sdata8, "sdata8")
408
 
409
  S(DW_EH_PE_absptr | DW_EH_PE_pcrel, "pcrel")
410
  S(DW_EH_PE_uleb128 | DW_EH_PE_pcrel, "pcrel uleb128")
411
  S(DW_EH_PE_udata2 | DW_EH_PE_pcrel, "pcrel udata2")
412
  S(DW_EH_PE_udata4 | DW_EH_PE_pcrel, "pcrel udata4")
413
  S(DW_EH_PE_udata8 | DW_EH_PE_pcrel, "pcrel udata8")
414
  S(DW_EH_PE_sleb128 | DW_EH_PE_pcrel, "pcrel sleb128")
415
  S(DW_EH_PE_sdata2 | DW_EH_PE_pcrel, "pcrel sdata2")
416
  S(DW_EH_PE_sdata4 | DW_EH_PE_pcrel, "pcrel sdata4")
417
  S(DW_EH_PE_sdata8 | DW_EH_PE_pcrel, "pcrel sdata8")
418
 
419
  S(DW_EH_PE_absptr | DW_EH_PE_textrel, "textrel")
420
  S(DW_EH_PE_uleb128 | DW_EH_PE_textrel, "textrel uleb128")
421
  S(DW_EH_PE_udata2 | DW_EH_PE_textrel, "textrel udata2")
422
  S(DW_EH_PE_udata4 | DW_EH_PE_textrel, "textrel udata4")
423
  S(DW_EH_PE_udata8 | DW_EH_PE_textrel, "textrel udata8")
424
  S(DW_EH_PE_sleb128 | DW_EH_PE_textrel, "textrel sleb128")
425
  S(DW_EH_PE_sdata2 | DW_EH_PE_textrel, "textrel sdata2")
426
  S(DW_EH_PE_sdata4 | DW_EH_PE_textrel, "textrel sdata4")
427
  S(DW_EH_PE_sdata8 | DW_EH_PE_textrel, "textrel sdata8")
428
 
429
  S(DW_EH_PE_absptr | DW_EH_PE_datarel, "datarel")
430
  S(DW_EH_PE_uleb128 | DW_EH_PE_datarel, "datarel uleb128")
431
  S(DW_EH_PE_udata2 | DW_EH_PE_datarel, "datarel udata2")
432
  S(DW_EH_PE_udata4 | DW_EH_PE_datarel, "datarel udata4")
433
  S(DW_EH_PE_udata8 | DW_EH_PE_datarel, "datarel udata8")
434
  S(DW_EH_PE_sleb128 | DW_EH_PE_datarel, "datarel sleb128")
435
  S(DW_EH_PE_sdata2 | DW_EH_PE_datarel, "datarel sdata2")
436
  S(DW_EH_PE_sdata4 | DW_EH_PE_datarel, "datarel sdata4")
437
  S(DW_EH_PE_sdata8 | DW_EH_PE_datarel, "datarel sdata8")
438
 
439
  S(DW_EH_PE_absptr | DW_EH_PE_funcrel, "funcrel")
440
  S(DW_EH_PE_uleb128 | DW_EH_PE_funcrel, "funcrel uleb128")
441
  S(DW_EH_PE_udata2 | DW_EH_PE_funcrel, "funcrel udata2")
442
  S(DW_EH_PE_udata4 | DW_EH_PE_funcrel, "funcrel udata4")
443
  S(DW_EH_PE_udata8 | DW_EH_PE_funcrel, "funcrel udata8")
444
  S(DW_EH_PE_sleb128 | DW_EH_PE_funcrel, "funcrel sleb128")
445
  S(DW_EH_PE_sdata2 | DW_EH_PE_funcrel, "funcrel sdata2")
446
  S(DW_EH_PE_sdata4 | DW_EH_PE_funcrel, "funcrel sdata4")
447
  S(DW_EH_PE_sdata8 | DW_EH_PE_funcrel, "funcrel sdata8")
448
 
449
  S(DW_EH_PE_indirect | DW_EH_PE_absptr, "indirect absolute")
450
 
451
  S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_pcrel,
452
    "indirect pcrel")
453
  S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel,
454
    "indirect pcrel uleb128")
455
  S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel,
456
    "indirect pcrel udata2")
457
  S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel,
458
    "indirect pcrel udata4")
459
  S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel,
460
    "indirect pcrel udata8")
461
  S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel,
462
    "indirect pcrel sleb128")
463
  S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel,
464
    "indirect pcrel sdata2")
465
  S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel,
466
    "indirect pcrel sdata4")
467
  S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel,
468
    "indirect pcrel sdata8")
469
 
470
  S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_textrel,
471
    "indirect textrel")
472
  S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel,
473
    "indirect textrel uleb128")
474
  S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel,
475
    "indirect textrel udata2")
476
  S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel,
477
    "indirect textrel udata4")
478
  S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel,
479
    "indirect textrel udata8")
480
  S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel,
481
    "indirect textrel sleb128")
482
  S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel,
483
    "indirect textrel sdata2")
484
  S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel,
485
    "indirect textrel sdata4")
486
  S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel,
487
    "indirect textrel sdata8")
488
 
489
  S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_datarel,
490
    "indirect datarel")
491
  S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel,
492
    "indirect datarel uleb128")
493
  S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel,
494
    "indirect datarel udata2")
495
  S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel,
496
    "indirect datarel udata4")
497
  S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel,
498
    "indirect datarel udata8")
499
  S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel,
500
    "indirect datarel sleb128")
501
  S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel,
502
    "indirect datarel sdata2")
503
  S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel,
504
    "indirect datarel sdata4")
505
  S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel,
506
    "indirect datarel sdata8")
507
 
508
  S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_funcrel,
509
    "indirect funcrel")
510
  S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel,
511
    "indirect funcrel uleb128")
512
  S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel,
513
    "indirect funcrel udata2")
514
  S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel,
515
    "indirect funcrel udata4")
516
  S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel,
517
    "indirect funcrel udata8")
518
  S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel,
519
    "indirect funcrel sleb128")
520
  S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel,
521
    "indirect funcrel sdata2")
522
  S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel,
523
    "indirect funcrel sdata4")
524
  S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel,
525
    "indirect funcrel sdata8")
526
 
527
#if HAVE_DESIGNATED_INITIALIZERS
528
  };
529
 
530
  gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
531
 
532
  return format_names[format];
533
#else
534
  }
535
  gcc_unreachable ();
536
#endif
537
}
538
 
539
/* Output an unsigned LEB128 quantity, but only the byte values.  */
540
 
541
void
542
dw2_asm_output_data_uleb128_raw (unsigned HOST_WIDE_INT value)
543
{
544
  while (1)
545
    {
546
      int byte = (value & 0x7f);
547
      value >>= 7;
548
      if (value != 0)
549
        /* More bytes to follow.  */
550
        byte |= 0x80;
551
 
552
      fprintf (asm_out_file, "0x%x", byte);
553
      if (value == 0)
554
        break;
555
      fputc (',', asm_out_file);
556
    }
557
}
558
 
559
/* Output an unsigned LEB128 quantity.  */
560
 
561
void
562
dw2_asm_output_data_uleb128 (unsigned HOST_WIDE_INT value,
563
                             const char *comment, ...)
564
{
565
  va_list ap;
566
 
567
  va_start (ap, comment);
568
 
569
#ifdef HAVE_AS_LEB128
570
  fprintf (asm_out_file, "\t.uleb128 " HOST_WIDE_INT_PRINT_HEX , value);
571
 
572
  if (flag_debug_asm && comment)
573
    {
574
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
575
      vfprintf (asm_out_file, comment, ap);
576
    }
577
#else
578
  {
579
    unsigned HOST_WIDE_INT work = value;
580
    const char *byte_op = targetm.asm_out.byte_op;
581
 
582
    if (byte_op)
583
      fputs (byte_op, asm_out_file);
584
    do
585
      {
586
        int byte = (work & 0x7f);
587
        work >>= 7;
588
        if (work != 0)
589
          /* More bytes to follow.  */
590
          byte |= 0x80;
591
 
592
        if (byte_op)
593
          {
594
            fprintf (asm_out_file, "0x%x", byte);
595
            if (work != 0)
596
              fputc (',', asm_out_file);
597
          }
598
        else
599
          assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
600
      }
601
    while (work != 0);
602
 
603
  if (flag_debug_asm)
604
    {
605
      fprintf (asm_out_file, "\t%s uleb128 " HOST_WIDE_INT_PRINT_HEX,
606
               ASM_COMMENT_START, value);
607
      if (comment)
608
        {
609
          fputs ("; ", asm_out_file);
610
          vfprintf (asm_out_file, comment, ap);
611
        }
612
    }
613
  }
614
#endif
615
  fputc ('\n', asm_out_file);
616
 
617
  va_end (ap);
618
}
619
 
620
/* Output an signed LEB128 quantity, but only the byte values.  */
621
 
622
void
623
dw2_asm_output_data_sleb128_raw (HOST_WIDE_INT value)
624
{
625
  int byte, more;
626
 
627
  while (1)
628
    {
629
      byte = (value & 0x7f);
630
      value >>= 7;
631
      more = !((value == 0 && (byte & 0x40) == 0)
632
                || (value == -1 && (byte & 0x40) != 0));
633
      if (more)
634
        byte |= 0x80;
635
 
636
      fprintf (asm_out_file, "0x%x", byte);
637
      if (!more)
638
        break;
639
      fputc (',', asm_out_file);
640
    }
641
}
642
 
643
/* Output a signed LEB128 quantity.  */
644
 
645
void
646
dw2_asm_output_data_sleb128 (HOST_WIDE_INT value,
647
                             const char *comment, ...)
648
{
649
  va_list ap;
650
 
651
  va_start (ap, comment);
652
 
653
#ifdef HAVE_AS_LEB128
654
  fprintf (asm_out_file, "\t.sleb128 " HOST_WIDE_INT_PRINT_DEC, value);
655
 
656
  if (flag_debug_asm && comment)
657
    {
658
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
659
      vfprintf (asm_out_file, comment, ap);
660
    }
661
#else
662
  {
663
    HOST_WIDE_INT work = value;
664
    int more, byte;
665
    const char *byte_op = targetm.asm_out.byte_op;
666
 
667
    if (byte_op)
668
      fputs (byte_op, asm_out_file);
669
    do
670
      {
671
        byte = (work & 0x7f);
672
        /* arithmetic shift */
673
        work >>= 7;
674
        more = !((work == 0 && (byte & 0x40) == 0)
675
                 || (work == -1 && (byte & 0x40) != 0));
676
        if (more)
677
          byte |= 0x80;
678
 
679
        if (byte_op)
680
          {
681
            fprintf (asm_out_file, "0x%x", byte);
682
            if (more)
683
              fputc (',', asm_out_file);
684
          }
685
        else
686
          assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
687
      }
688
    while (more);
689
 
690
  if (flag_debug_asm)
691
    {
692
      fprintf (asm_out_file, "\t%s sleb128 " HOST_WIDE_INT_PRINT_DEC,
693
               ASM_COMMENT_START, value);
694
      if (comment)
695
        {
696
          fputs ("; ", asm_out_file);
697
          vfprintf (asm_out_file, comment, ap);
698
        }
699
    }
700
  }
701
#endif
702
  fputc ('\n', asm_out_file);
703
 
704
  va_end (ap);
705
}
706
 
707
void
708
dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
709
                              const char *lab2 ATTRIBUTE_UNUSED,
710
                              const char *comment, ...)
711
{
712
  va_list ap;
713
 
714
  va_start (ap, comment);
715
 
716
#ifdef HAVE_AS_LEB128
717
  fputs ("\t.uleb128 ", asm_out_file);
718
  assemble_name (asm_out_file, lab1);
719
  fputc ('-', asm_out_file);
720
  assemble_name (asm_out_file, lab2);
721
#else
722
  gcc_unreachable ();
723
#endif
724
 
725
  if (flag_debug_asm && comment)
726
    {
727
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
728
      vfprintf (asm_out_file, comment, ap);
729
    }
730
  fputc ('\n', asm_out_file);
731
 
732
  va_end (ap);
733
}
734
 
735
#if 0
736
 
737
void
738
dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED,
739
                              const char *lab2 ATTRIBUTE_UNUSED,
740
                              const char *comment, ...)
741
{
742
  va_list ap;
743
 
744
  va_start (ap, comment);
745
 
746
#ifdef HAVE_AS_LEB128
747
  fputs ("\t.sleb128 ", asm_out_file);
748
  assemble_name (asm_out_file, lab1);
749
  fputc ('-', asm_out_file);
750
  assemble_name (asm_out_file, lab2);
751
#else
752
  gcc_unreachable ();
753
#endif
754
 
755
  if (flag_debug_asm && comment)
756
    {
757
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
758
      vfprintf (asm_out_file, comment, ap);
759
    }
760
  fputc ('\n', asm_out_file);
761
 
762
  va_end (ap);
763
}
764
#endif /* 0 */
765
 
766
static int dw2_output_indirect_constant_1 (splay_tree_node, void *);
767
 
768
static GTY((param1_is (char *), param2_is (tree))) splay_tree indirect_pool;
769
 
770
static GTY(()) int dw2_const_labelno;
771
 
772
#if defined(HAVE_GAS_HIDDEN) && defined(SUPPORTS_ONE_ONLY)
773
# define USE_LINKONCE_INDIRECT 1
774
#else
775
# define USE_LINKONCE_INDIRECT 0
776
#endif
777
 
778
/* Comparison function for a splay tree in which the keys are strings.
779
   K1 and K2 have the dynamic type "const char *".  Returns <0, 0, or
780
   >0 to indicate whether K1 is less than, equal to, or greater than
781
   K2, respectively.  */
782
 
783
static int
784
splay_tree_compare_strings (splay_tree_key k1, splay_tree_key k2)
785
{
786
  const char *s1 = (const char *)k1;
787
  const char *s2 = (const char *)k2;
788
  int ret;
789
 
790
  if (s1 == s2)
791
    return 0;
792
 
793
  ret = strcmp (s1, s2);
794
 
795
  /* The strings are always those from IDENTIFIER_NODEs, and,
796
     therefore, we should never have two copies of the same
797
     string.  */
798
  gcc_assert (ret);
799
 
800
  return ret;
801
}
802
 
803
/* Put X, a SYMBOL_REF, in memory.  Return a SYMBOL_REF to the allocated
804
   memory.  Differs from force_const_mem in that a single pool is used for
805
   the entire unit of translation, and the memory is not guaranteed to be
806
   "near" the function in any interesting sense.  IS_PUBLIC controls whether
807
   the symbol can be shared across the entire application (or DSO).  */
808
 
809
rtx
810
dw2_force_const_mem (rtx x, bool is_public)
811
{
812
  splay_tree_node node;
813
  const char *key;
814
  tree decl_id;
815
 
816
  if (! indirect_pool)
817
    /* We use strcmp, rather than just comparing pointers, so that the
818
       sort order will not depend on the host system.  */
819
    indirect_pool = splay_tree_new_ggc (splay_tree_compare_strings);
820
 
821
  gcc_assert (GET_CODE (x) == SYMBOL_REF);
822
 
823
  key = XSTR (x, 0);
824
  node = splay_tree_lookup (indirect_pool, (splay_tree_key) key);
825
  if (node)
826
    decl_id = (tree) node->value;
827
  else
828
    {
829
      tree id;
830
      const char *str = targetm.strip_name_encoding (key);
831
 
832
      if (is_public && USE_LINKONCE_INDIRECT)
833
        {
834
          char *ref_name = XALLOCAVEC (char, strlen (str) + sizeof "DW.ref.");
835
 
836
          sprintf (ref_name, "DW.ref.%s", str);
837
          gcc_assert (!maybe_get_identifier (ref_name));
838
          decl_id = get_identifier (ref_name);
839
          TREE_PUBLIC (decl_id) = 1;
840
        }
841
      else
842
        {
843
          char label[32];
844
 
845
          ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno);
846
          ++dw2_const_labelno;
847
          gcc_assert (!maybe_get_identifier (label));
848
          decl_id = get_identifier (label);
849
        }
850
 
851
      id = maybe_get_identifier (str);
852
      if (id)
853
        TREE_SYMBOL_REFERENCED (id) = 1;
854
 
855
      splay_tree_insert (indirect_pool, (splay_tree_key) key,
856
                         (splay_tree_value) decl_id);
857
    }
858
 
859
  return gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (decl_id));
860
}
861
 
862
/* A helper function for dw2_output_indirect_constants called through
863
   splay_tree_foreach.  Emit one queued constant to memory.  */
864
 
865
static int
866
dw2_output_indirect_constant_1 (splay_tree_node node,
867
                                void *data ATTRIBUTE_UNUSED)
868
{
869
  const char *sym;
870
  rtx sym_ref;
871
  tree id, decl;
872
 
873
  sym = (const char *) node->key;
874
  id = (tree) node->value;
875
 
876
  decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, id, ptr_type_node);
877
  DECL_ARTIFICIAL (decl) = 1;
878
  DECL_IGNORED_P (decl) = 1;
879
  DECL_INITIAL (decl) = decl;
880
  TREE_READONLY (decl) = 1;
881
 
882
  if (TREE_PUBLIC (id))
883
    {
884
      TREE_PUBLIC (decl) = 1;
885
      make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
886
    }
887
  else
888
    TREE_STATIC (decl) = 1;
889
 
890
  sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
891
  sym = targetm.strip_name_encoding (sym);
892
  if (TREE_PUBLIC (decl) && USE_LINKONCE_INDIRECT)
893
    fprintf (asm_out_file, "\t.hidden %sDW.ref.%s\n", user_label_prefix, sym);
894
  assemble_variable (decl, 1, 1, 1);
895
  assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
896
 
897
  return 0;
898
}
899
 
900
/* Emit the constants queued through dw2_force_const_mem.  */
901
 
902
void
903
dw2_output_indirect_constants (void)
904
{
905
  if (indirect_pool)
906
    splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
907
}
908
 
909
/* Like dw2_asm_output_addr_rtx, but encode the pointer as directed.
910
   If PUBLIC is set and the encoding is DW_EH_PE_indirect, the indirect
911
   reference is shared across the entire application (or DSO).  */
912
 
913
void
914
dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr, bool is_public,
915
                                 const char *comment, ...)
916
{
917
  int size;
918
  va_list ap;
919
 
920
  va_start (ap, comment);
921
 
922
  size = size_of_encoded_value (encoding);
923
 
924
  if (encoding == DW_EH_PE_aligned)
925
    {
926
      assemble_align (POINTER_SIZE);
927
      assemble_integer (addr, size, POINTER_SIZE, 1);
928
      return;
929
    }
930
 
931
  /* NULL is _always_ represented as a plain zero, as is 1 for Ada's
932
     "all others".  */
933
  if (addr == const0_rtx || addr == const1_rtx)
934
    assemble_integer (addr, size, BITS_PER_UNIT, 1);
935
  else
936
    {
937
    restart:
938
      /* Allow the target first crack at emitting this.  Some of the
939
         special relocations require special directives instead of
940
         just ".4byte" or whatever.  */
941
#ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
942
      ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
943
                                         addr, done);
944
#endif
945
 
946
      /* Indirection is used to get dynamic relocations out of a
947
         read-only section.  */
948
      if (encoding & DW_EH_PE_indirect)
949
        {
950
          /* It is very tempting to use force_const_mem so that we share data
951
             with the normal constant pool.  However, we've already emitted
952
             the constant pool for this function.  Moreover, we'd like to
953
             share these constants across the entire unit of translation and
954
             even, if possible, across the entire application (or DSO).  */
955
          addr = dw2_force_const_mem (addr, is_public);
956
          encoding &= ~DW_EH_PE_indirect;
957
          goto restart;
958
        }
959
 
960
      switch (encoding & 0xF0)
961
        {
962
        case DW_EH_PE_absptr:
963
          dw2_assemble_integer (size, addr);
964
          break;
965
 
966
        case DW_EH_PE_pcrel:
967
          gcc_assert (GET_CODE (addr) == SYMBOL_REF);
968
#ifdef ASM_OUTPUT_DWARF_PCREL
969
          ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
970
#else
971
          dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx));
972
#endif
973
          break;
974
 
975
        default:
976
          /* Other encodings should have been handled by
977
             ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX.  */
978
          gcc_unreachable ();
979
        }
980
 
981
#ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
982
    done:;
983
#endif
984
    }
985
 
986
  if (flag_debug_asm && comment)
987
    {
988
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
989
      vfprintf (asm_out_file, comment, ap);
990
    }
991
  fputc ('\n', asm_out_file);
992
 
993
  va_end (ap);
994
}
995
 
996
#include "gt-dwarf2asm.h"

powered by: WebSVN 2.1.0

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