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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [cp/] [mangle.c] - Blame information for rev 294

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

Line No. Rev Author Line
1 283 jeremybenn
/* Name mangling for the 3.0 C++ ABI.
2
   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
3
   Free Software Foundation, Inc.
4
   Written by Alex Samuel <samuel@codesourcery.com>
5
 
6
   This file is part of GCC.
7
 
8
   GCC is free software; you can redistribute it and/or modify it
9
   under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3, or (at your option)
11
   any later version.
12
 
13
   GCC is distributed in the hope that it will be useful, but
14
   WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
   General Public License for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
/* This file implements mangling of C++ names according to the IA64
23
   C++ ABI specification.  A mangled name encodes a function or
24
   variable's name, scope, type, and/or template arguments into a text
25
   identifier.  This identifier is used as the function's or
26
   variable's linkage name, to preserve compatibility between C++'s
27
   language features (templates, scoping, and overloading) and C
28
   linkers.
29
 
30
   Additionally, g++ uses mangled names internally.  To support this,
31
   mangling of types is allowed, even though the mangled name of a
32
   type should not appear by itself as an exported name.  Ditto for
33
   uninstantiated templates.
34
 
35
   The primary entry point for this module is mangle_decl, which
36
   returns an identifier containing the mangled name for a decl.
37
   Additional entry points are provided to build mangled names of
38
   particular constructs when the appropriate decl for that construct
39
   is not available.  These are:
40
 
41
     mangle_typeinfo_for_type:          typeinfo data
42
     mangle_typeinfo_string_for_type:   typeinfo type name
43
     mangle_vtbl_for_type:              virtual table data
44
     mangle_vtt_for_type:               VTT data
45
     mangle_ctor_vtbl_for_type:         `C-in-B' constructor virtual table data
46
     mangle_thunk:                      thunk function or entry  */
47
 
48
#include "config.h"
49
#include "system.h"
50
#include "coretypes.h"
51
#include "tm.h"
52
#include "tree.h"
53
#include "tm_p.h"
54
#include "cp-tree.h"
55
#include "real.h"
56
#include "obstack.h"
57
#include "toplev.h"
58
#include "varray.h"
59
#include "flags.h"
60
#include "target.h"
61
#include "cgraph.h"
62
 
63
/* Debugging support.  */
64
 
65
/* Define DEBUG_MANGLE to enable very verbose trace messages.  */
66
#ifndef DEBUG_MANGLE
67
#define DEBUG_MANGLE 0
68
#endif
69
 
70
/* Macros for tracing the write_* functions.  */
71
#if DEBUG_MANGLE
72
# define MANGLE_TRACE(FN, INPUT) \
73
  fprintf (stderr, "  %-24s: %-24s\n", (FN), (INPUT))
74
# define MANGLE_TRACE_TREE(FN, NODE) \
75
  fprintf (stderr, "  %-24s: %-24s (%p)\n", \
76
           (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
77
#else
78
# define MANGLE_TRACE(FN, INPUT)
79
# define MANGLE_TRACE_TREE(FN, NODE)
80
#endif
81
 
82
/* Nonzero if NODE is a class template-id.  We can't rely on
83
   CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
84
   that hard to distinguish A<T> from A, where A<T> is the type as
85
   instantiated outside of the template, and A is the type used
86
   without parameters inside the template.  */
87
#define CLASSTYPE_TEMPLATE_ID_P(NODE)                                   \
88
  (TYPE_LANG_SPECIFIC (NODE) != NULL                                    \
89
   && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                 \
90
       || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL                       \
91
           && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
92
 
93
/* Things we only need one of.  This module is not reentrant.  */
94
typedef struct GTY(()) globals {
95
  /* An array of the current substitution candidates, in the order
96
     we've seen them.  */
97
  VEC(tree,gc) *substitutions;
98
 
99
  /* The entity that is being mangled.  */
100
  tree GTY ((skip)) entity;
101
 
102
  /* True if the mangling will be different in a future version of the
103
     ABI.  */
104
  bool need_abi_warning;
105
} globals;
106
 
107
static GTY (()) globals G;
108
 
109
/* The obstack on which we build mangled names.  */
110
static struct obstack *mangle_obstack;
111
 
112
/* The obstack on which we build mangled names that are not going to
113
   be IDENTIFIER_NODEs.  */
114
static struct obstack name_obstack;
115
 
116
/* The first object on the name_obstack; we use this to free memory
117
   allocated on the name_obstack.  */
118
static void *name_base;
119
 
120
/* Indices into subst_identifiers.  These are identifiers used in
121
   special substitution rules.  */
122
typedef enum
123
{
124
  SUBID_ALLOCATOR,
125
  SUBID_BASIC_STRING,
126
  SUBID_CHAR_TRAITS,
127
  SUBID_BASIC_ISTREAM,
128
  SUBID_BASIC_OSTREAM,
129
  SUBID_BASIC_IOSTREAM,
130
  SUBID_MAX
131
}
132
substitution_identifier_index_t;
133
 
134
/* For quick substitution checks, look up these common identifiers
135
   once only.  */
136
static GTY(()) tree subst_identifiers[SUBID_MAX];
137
 
138
/* Single-letter codes for builtin integer types, defined in
139
   <builtin-type>.  These are indexed by integer_type_kind values.  */
140
static const char
141
integer_type_codes[itk_none] =
142
{
143
  'c',  /* itk_char */
144
  'a',  /* itk_signed_char */
145
  'h',  /* itk_unsigned_char */
146
  's',  /* itk_short */
147
  't',  /* itk_unsigned_short */
148
  'i',  /* itk_int */
149
  'j',  /* itk_unsigned_int */
150
  'l',  /* itk_long */
151
  'm',  /* itk_unsigned_long */
152
  'x',  /* itk_long_long */
153
  'y'   /* itk_unsigned_long_long */
154
};
155
 
156
static int decl_is_template_id (const tree, tree* const);
157
 
158
/* Functions for handling substitutions.  */
159
 
160
static inline tree canonicalize_for_substitution (tree);
161
static void add_substitution (tree);
162
static inline int is_std_substitution (const tree,
163
                                       const substitution_identifier_index_t);
164
static inline int is_std_substitution_char (const tree,
165
                                            const substitution_identifier_index_t);
166
static int find_substitution (tree);
167
static void mangle_call_offset (const tree, const tree);
168
 
169
/* Functions for emitting mangled representations of things.  */
170
 
171
static void write_mangled_name (const tree, bool);
172
static void write_encoding (const tree);
173
static void write_name (tree, const int);
174
static void write_unscoped_name (const tree);
175
static void write_unscoped_template_name (const tree);
176
static void write_nested_name (const tree);
177
static void write_prefix (const tree);
178
static void write_template_prefix (const tree);
179
static void write_unqualified_name (const tree);
180
static void write_conversion_operator_name (const tree);
181
static void write_source_name (tree);
182
static void write_unnamed_type_name (const tree);
183
static void write_closure_type_name (const tree);
184
static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
185
                           const unsigned int);
186
static void write_number (unsigned HOST_WIDE_INT, const int,
187
                          const unsigned int);
188
static void write_compact_number (int num);
189
static void write_integer_cst (const tree);
190
static void write_real_cst (const tree);
191
static void write_identifier (const char *);
192
static void write_special_name_constructor (const tree);
193
static void write_special_name_destructor (const tree);
194
static void write_type (tree);
195
static int write_CV_qualifiers_for_type (const tree);
196
static void write_builtin_type (tree);
197
static void write_function_type (const tree);
198
static void write_bare_function_type (const tree, const int, const tree);
199
static void write_method_parms (tree, const int, const tree);
200
static void write_class_enum_type (const tree);
201
static void write_template_args (tree);
202
static void write_expression (tree);
203
static void write_template_arg_literal (const tree);
204
static void write_template_arg (tree);
205
static void write_template_template_arg (const tree);
206
static void write_array_type (const tree);
207
static void write_pointer_to_member_type (const tree);
208
static void write_template_param (const tree);
209
static void write_template_template_param (const tree);
210
static void write_substitution (const int);
211
static int discriminator_for_local_entity (tree);
212
static int discriminator_for_string_literal (tree, tree);
213
static void write_discriminator (const int);
214
static void write_local_name (tree, const tree, const tree);
215
static void dump_substitution_candidates (void);
216
static tree mangle_decl_string (const tree);
217
static int local_class_index (tree);
218
 
219
/* Control functions.  */
220
 
221
static inline void start_mangling (const tree);
222
static inline const char *finish_mangling (const bool);
223
static tree mangle_special_for_type (const tree, const char *);
224
 
225
/* Foreign language functions.  */
226
 
227
static void write_java_integer_type_codes (const tree);
228
 
229
/* Append a single character to the end of the mangled
230
   representation.  */
231
#define write_char(CHAR)                                                \
232
  obstack_1grow (mangle_obstack, (CHAR))
233
 
234
/* Append a sized buffer to the end of the mangled representation.  */
235
#define write_chars(CHAR, LEN)                                          \
236
  obstack_grow (mangle_obstack, (CHAR), (LEN))
237
 
238
/* Append a NUL-terminated string to the end of the mangled
239
   representation.  */
240
#define write_string(STRING)                                            \
241
  obstack_grow (mangle_obstack, (STRING), strlen (STRING))
242
 
243
/* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
244
   same purpose (context, which may be a type) and value (template
245
   decl).  See write_template_prefix for more information on what this
246
   is used for.  */
247
#define NESTED_TEMPLATE_MATCH(NODE1, NODE2)                             \
248
  (TREE_CODE (NODE1) == TREE_LIST                                       \
249
   && TREE_CODE (NODE2) == TREE_LIST                                    \
250
   && ((TYPE_P (TREE_PURPOSE (NODE1))                                   \
251
        && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))    \
252
       || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2))                 \
253
   && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
254
 
255
/* Write out an unsigned quantity in base 10.  */
256
#define write_unsigned_number(NUMBER)                                   \
257
  write_number ((NUMBER), /*unsigned_p=*/1, 10)
258
 
259
/* If DECL is a template instance, return nonzero and, if
260
   TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
261
   Otherwise return zero.  */
262
 
263
static int
264
decl_is_template_id (const tree decl, tree* const template_info)
265
{
266
  if (TREE_CODE (decl) == TYPE_DECL)
267
    {
268
      /* TYPE_DECLs are handled specially.  Look at its type to decide
269
         if this is a template instantiation.  */
270
      const tree type = TREE_TYPE (decl);
271
 
272
      if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
273
        {
274
          if (template_info != NULL)
275
            /* For a templated TYPE_DECL, the template info is hanging
276
               off the type.  */
277
            *template_info = TYPE_TEMPLATE_INFO (type);
278
          return 1;
279
        }
280
    }
281
  else
282
    {
283
      /* Check if this is a primary template.  */
284
      if (DECL_LANG_SPECIFIC (decl) != NULL
285
          && DECL_USE_TEMPLATE (decl)
286
          && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
287
          && TREE_CODE (decl) != TEMPLATE_DECL)
288
        {
289
          if (template_info != NULL)
290
            /* For most templated decls, the template info is hanging
291
               off the decl.  */
292
            *template_info = DECL_TEMPLATE_INFO (decl);
293
          return 1;
294
        }
295
    }
296
 
297
  /* It's not a template id.  */
298
  return 0;
299
}
300
 
301
/* Produce debugging output of current substitution candidates.  */
302
 
303
static void
304
dump_substitution_candidates (void)
305
{
306
  unsigned i;
307
  tree el;
308
 
309
  fprintf (stderr, "  ++ substitutions  ");
310
  for (i = 0; VEC_iterate (tree, G.substitutions, i, el); ++i)
311
    {
312
      const char *name = "???";
313
 
314
      if (i > 0)
315
        fprintf (stderr, "                    ");
316
      if (DECL_P (el))
317
        name = IDENTIFIER_POINTER (DECL_NAME (el));
318
      else if (TREE_CODE (el) == TREE_LIST)
319
        name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
320
      else if (TYPE_NAME (el))
321
        name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
322
      fprintf (stderr, " S%d_ = ", i - 1);
323
      if (TYPE_P (el) &&
324
          (CP_TYPE_RESTRICT_P (el)
325
           || CP_TYPE_VOLATILE_P (el)
326
           || CP_TYPE_CONST_P (el)))
327
        fprintf (stderr, "CV-");
328
      fprintf (stderr, "%s (%s at %p)\n",
329
               name, tree_code_name[TREE_CODE (el)], (void *) el);
330
    }
331
}
332
 
333
/* Both decls and types can be substitution candidates, but sometimes
334
   they refer to the same thing.  For instance, a TYPE_DECL and
335
   RECORD_TYPE for the same class refer to the same thing, and should
336
   be treated accordingly in substitutions.  This function returns a
337
   canonicalized tree node representing NODE that is used when adding
338
   and substitution candidates and finding matches.  */
339
 
340
static inline tree
341
canonicalize_for_substitution (tree node)
342
{
343
  /* For a TYPE_DECL, use the type instead.  */
344
  if (TREE_CODE (node) == TYPE_DECL)
345
    node = TREE_TYPE (node);
346
  if (TYPE_P (node)
347
      && TYPE_CANONICAL (node) != node
348
      && TYPE_MAIN_VARIANT (node) != node)
349
      /* Here we want to strip the topmost typedef only.
350
         We need to do that so is_std_substitution can do proper
351
         name matching.  */
352
    node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
353
                                    cp_type_quals (node));
354
  return node;
355
}
356
 
357
/* Add NODE as a substitution candidate.  NODE must not already be on
358
   the list of candidates.  */
359
 
360
static void
361
add_substitution (tree node)
362
{
363
  tree c;
364
 
365
  if (DEBUG_MANGLE)
366
    fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
367
             tree_code_name[TREE_CODE (node)], (void *) node);
368
 
369
  /* Get the canonicalized substitution candidate for NODE.  */
370
  c = canonicalize_for_substitution (node);
371
  if (DEBUG_MANGLE && c != node)
372
    fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
373
             tree_code_name[TREE_CODE (node)], (void *) node);
374
  node = c;
375
 
376
#if ENABLE_CHECKING
377
  /* Make sure NODE isn't already a candidate.  */
378
  {
379
    int i;
380
    tree candidate;
381
 
382
    for (i = 0; VEC_iterate (tree, G.substitutions, i, candidate); i++)
383
      {
384
        gcc_assert (!(DECL_P (node) && node == candidate));
385
        gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
386
                      && same_type_p (node, candidate)));
387
      }
388
  }
389
#endif /* ENABLE_CHECKING */
390
 
391
  /* Put the decl onto the varray of substitution candidates.  */
392
  VEC_safe_push (tree, gc, G.substitutions, node);
393
 
394
  if (DEBUG_MANGLE)
395
    dump_substitution_candidates ();
396
}
397
 
398
/* Helper function for find_substitution.  Returns nonzero if NODE,
399
   which may be a decl or a CLASS_TYPE, is a template-id with template
400
   name of substitution_index[INDEX] in the ::std namespace.  */
401
 
402
static inline int
403
is_std_substitution (const tree node,
404
                     const substitution_identifier_index_t index)
405
{
406
  tree type = NULL;
407
  tree decl = NULL;
408
 
409
  if (DECL_P (node))
410
    {
411
      type = TREE_TYPE (node);
412
      decl = node;
413
    }
414
  else if (CLASS_TYPE_P (node))
415
    {
416
      type = node;
417
      decl = TYPE_NAME (node);
418
    }
419
  else
420
    /* These are not the droids you're looking for.  */
421
    return 0;
422
 
423
  return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
424
          && TYPE_LANG_SPECIFIC (type)
425
          && TYPE_TEMPLATE_INFO (type)
426
          && (DECL_NAME (TYPE_TI_TEMPLATE (type))
427
              == subst_identifiers[index]));
428
}
429
 
430
/* Helper function for find_substitution.  Returns nonzero if NODE,
431
   which may be a decl or a CLASS_TYPE, is the template-id
432
   ::std::identifier<char>, where identifier is
433
   substitution_index[INDEX].  */
434
 
435
static inline int
436
is_std_substitution_char (const tree node,
437
                          const substitution_identifier_index_t index)
438
{
439
  tree args;
440
  /* Check NODE's name is ::std::identifier.  */
441
  if (!is_std_substitution (node, index))
442
    return 0;
443
  /* Figure out its template args.  */
444
  if (DECL_P (node))
445
    args = DECL_TI_ARGS (node);
446
  else if (CLASS_TYPE_P (node))
447
    args = CLASSTYPE_TI_ARGS (node);
448
  else
449
    /* Oops, not a template.  */
450
    return 0;
451
  /* NODE's template arg list should be <char>.  */
452
  return
453
    TREE_VEC_LENGTH (args) == 1
454
    && TREE_VEC_ELT (args, 0) == char_type_node;
455
}
456
 
457
/* Check whether a substitution should be used to represent NODE in
458
   the mangling.
459
 
460
   First, check standard special-case substitutions.
461
 
462
     <substitution> ::= St
463
         # ::std
464
 
465
                    ::= Sa
466
         # ::std::allocator
467
 
468
                    ::= Sb
469
         # ::std::basic_string
470
 
471
                    ::= Ss
472
         # ::std::basic_string<char,
473
                               ::std::char_traits<char>,
474
                               ::std::allocator<char> >
475
 
476
                    ::= Si
477
         # ::std::basic_istream<char, ::std::char_traits<char> >
478
 
479
                    ::= So
480
         # ::std::basic_ostream<char, ::std::char_traits<char> >
481
 
482
                    ::= Sd
483
         # ::std::basic_iostream<char, ::std::char_traits<char> >
484
 
485
   Then examine the stack of currently available substitution
486
   candidates for entities appearing earlier in the same mangling
487
 
488
   If a substitution is found, write its mangled representation and
489
   return nonzero.  If none is found, just return zero.  */
490
 
491
static int
492
find_substitution (tree node)
493
{
494
  int i;
495
  const int size = VEC_length (tree, G.substitutions);
496
  tree decl;
497
  tree type;
498
 
499
  if (DEBUG_MANGLE)
500
    fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
501
             tree_code_name[TREE_CODE (node)], (void *) node);
502
 
503
  /* Obtain the canonicalized substitution representation for NODE.
504
     This is what we'll compare against.  */
505
  node = canonicalize_for_substitution (node);
506
 
507
  /* Check for builtin substitutions.  */
508
 
509
  decl = TYPE_P (node) ? TYPE_NAME (node) : node;
510
  type = TYPE_P (node) ? node : TREE_TYPE (node);
511
 
512
  /* Check for std::allocator.  */
513
  if (decl
514
      && is_std_substitution (decl, SUBID_ALLOCATOR)
515
      && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
516
    {
517
      write_string ("Sa");
518
      return 1;
519
    }
520
 
521
  /* Check for std::basic_string.  */
522
  if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
523
    {
524
      if (TYPE_P (node))
525
        {
526
          /* If this is a type (i.e. a fully-qualified template-id),
527
             check for
528
                 std::basic_string <char,
529
                                    std::char_traits<char>,
530
                                    std::allocator<char> > .  */
531
          if (cp_type_quals (type) == TYPE_UNQUALIFIED
532
              && CLASSTYPE_USE_TEMPLATE (type))
533
            {
534
              tree args = CLASSTYPE_TI_ARGS (type);
535
              if (TREE_VEC_LENGTH (args) == 3
536
                  && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
537
                  && is_std_substitution_char (TREE_VEC_ELT (args, 1),
538
                                               SUBID_CHAR_TRAITS)
539
                  && is_std_substitution_char (TREE_VEC_ELT (args, 2),
540
                                               SUBID_ALLOCATOR))
541
                {
542
                  write_string ("Ss");
543
                  return 1;
544
                }
545
            }
546
        }
547
      else
548
        /* Substitute for the template name only if this isn't a type.  */
549
        {
550
          write_string ("Sb");
551
          return 1;
552
        }
553
    }
554
 
555
  /* Check for basic_{i,o,io}stream.  */
556
  if (TYPE_P (node)
557
      && cp_type_quals (type) == TYPE_UNQUALIFIED
558
      && CLASS_TYPE_P (type)
559
      && CLASSTYPE_USE_TEMPLATE (type)
560
      && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
561
    {
562
      /* First, check for the template
563
         args <char, std::char_traits<char> > .  */
564
      tree args = CLASSTYPE_TI_ARGS (type);
565
      if (TREE_VEC_LENGTH (args) == 2
566
          && TYPE_P (TREE_VEC_ELT (args, 0))
567
          && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
568
          && is_std_substitution_char (TREE_VEC_ELT (args, 1),
569
                                       SUBID_CHAR_TRAITS))
570
        {
571
          /* Got them.  Is this basic_istream?  */
572
          if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
573
            {
574
              write_string ("Si");
575
              return 1;
576
            }
577
          /* Or basic_ostream?  */
578
          else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
579
            {
580
              write_string ("So");
581
              return 1;
582
            }
583
          /* Or basic_iostream?  */
584
          else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
585
            {
586
              write_string ("Sd");
587
              return 1;
588
            }
589
        }
590
    }
591
 
592
  /* Check for namespace std.  */
593
  if (decl && DECL_NAMESPACE_STD_P (decl))
594
    {
595
      write_string ("St");
596
      return 1;
597
    }
598
 
599
  /* Now check the list of available substitutions for this mangling
600
     operation.  */
601
  for (i = 0; i < size; ++i)
602
    {
603
      tree candidate = VEC_index (tree, G.substitutions, i);
604
      /* NODE is a matched to a candidate if it's the same decl node or
605
         if it's the same type.  */
606
      if (decl == candidate
607
          || (TYPE_P (candidate) && type && TYPE_P (type)
608
              && same_type_p (type, candidate))
609
          || NESTED_TEMPLATE_MATCH (node, candidate))
610
        {
611
          write_substitution (i);
612
          return 1;
613
        }
614
    }
615
 
616
  /* No substitution found.  */
617
  return 0;
618
}
619
 
620
 
621
/* TOP_LEVEL is true, if this is being called at outermost level of
622
  mangling. It should be false when mangling a decl appearing in an
623
  expression within some other mangling.
624
 
625
  <mangled-name>      ::= _Z <encoding>  */
626
 
627
static void
628
write_mangled_name (const tree decl, bool top_level)
629
{
630
  MANGLE_TRACE_TREE ("mangled-name", decl);
631
 
632
  if (/* The names of `extern "C"' functions are not mangled.  */
633
      DECL_EXTERN_C_FUNCTION_P (decl)
634
      /* But overloaded operator names *are* mangled.  */
635
      && !DECL_OVERLOADED_OPERATOR_P (decl))
636
    {
637
    unmangled_name:;
638
 
639
      if (top_level)
640
        write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
641
      else
642
        {
643
          /* The standard notes: "The <encoding> of an extern "C"
644
             function is treated like global-scope data, i.e. as its
645
             <source-name> without a type."  We cannot write
646
             overloaded operators that way though, because it contains
647
             characters invalid in assembler.  */
648
          if (abi_version_at_least (2))
649
            write_string ("_Z");
650
          else
651
            G.need_abi_warning = true;
652
          write_source_name (DECL_NAME (decl));
653
        }
654
    }
655
  else if (TREE_CODE (decl) == VAR_DECL
656
           /* The names of non-static global variables aren't mangled.  */
657
           && DECL_EXTERNAL_LINKAGE_P (decl)
658
           && (CP_DECL_CONTEXT (decl) == global_namespace
659
               /* And neither are `extern "C"' variables.  */
660
               || DECL_EXTERN_C_P (decl)))
661
    {
662
      if (top_level || abi_version_at_least (2))
663
        goto unmangled_name;
664
      else
665
        {
666
          G.need_abi_warning = true;
667
          goto mangled_name;
668
        }
669
    }
670
  else
671
    {
672
    mangled_name:;
673
      write_string ("_Z");
674
      write_encoding (decl);
675
      if (DECL_LANG_SPECIFIC (decl)
676
          && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
677
              || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
678
        /* We need a distinct mangled name for these entities, but
679
           we should never actually output it.  So, we append some
680
           characters the assembler won't like.  */
681
        write_string (" *INTERNAL* ");
682
    }
683
}
684
 
685
/*   <encoding>         ::= <function name> <bare-function-type>
686
                        ::= <data name>  */
687
 
688
static void
689
write_encoding (const tree decl)
690
{
691
  MANGLE_TRACE_TREE ("encoding", decl);
692
 
693
  if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
694
    {
695
      /* For overloaded operators write just the mangled name
696
         without arguments.  */
697
      if (DECL_OVERLOADED_OPERATOR_P (decl))
698
        write_name (decl, /*ignore_local_scope=*/0);
699
      else
700
        write_source_name (DECL_NAME (decl));
701
      return;
702
    }
703
 
704
  write_name (decl, /*ignore_local_scope=*/0);
705
  if (TREE_CODE (decl) == FUNCTION_DECL)
706
    {
707
      tree fn_type;
708
      tree d;
709
 
710
      if (decl_is_template_id (decl, NULL))
711
        {
712
          fn_type = get_mostly_instantiated_function_type (decl);
713
          /* FN_TYPE will not have parameter types for in-charge or
714
             VTT parameters.  Therefore, we pass NULL_TREE to
715
             write_bare_function_type -- otherwise, it will get
716
             confused about which artificial parameters to skip.  */
717
          d = NULL_TREE;
718
        }
719
      else
720
        {
721
          fn_type = TREE_TYPE (decl);
722
          d = decl;
723
        }
724
 
725
      write_bare_function_type (fn_type,
726
                                (!DECL_CONSTRUCTOR_P (decl)
727
                                 && !DECL_DESTRUCTOR_P (decl)
728
                                 && !DECL_CONV_FN_P (decl)
729
                                 && decl_is_template_id (decl, NULL)),
730
                                d);
731
    }
732
}
733
 
734
/* Lambdas can have a bit more context for mangling, specifically VAR_DECL
735
   or PARM_DECL context, which doesn't belong in DECL_CONTEXT.  */
736
 
737
static tree
738
decl_mangling_context (tree decl)
739
{
740
  if (TREE_CODE (decl) == TYPE_DECL
741
      && LAMBDA_TYPE_P (TREE_TYPE (decl)))
742
    {
743
      tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
744
      if (extra)
745
        return extra;
746
    }
747
    else if (TREE_CODE (decl) == TYPE_DECL
748
             && TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TYPE_PARM)
749
     /* template type parms have no mangling context.  */
750
      return NULL_TREE;
751
  return CP_DECL_CONTEXT (decl);
752
}
753
 
754
/* <name> ::= <unscoped-name>
755
          ::= <unscoped-template-name> <template-args>
756
          ::= <nested-name>
757
          ::= <local-name>
758
 
759
   If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
760
   called from <local-name>, which mangles the enclosing scope
761
   elsewhere and then uses this function to mangle just the part
762
   underneath the function scope.  So don't use the <local-name>
763
   production, to avoid an infinite recursion.  */
764
 
765
static void
766
write_name (tree decl, const int ignore_local_scope)
767
{
768
  tree context;
769
 
770
  MANGLE_TRACE_TREE ("name", decl);
771
 
772
  if (TREE_CODE (decl) == TYPE_DECL)
773
    {
774
      /* In case this is a typedef, fish out the corresponding
775
         TYPE_DECL for the main variant.  */
776
      decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
777
    }
778
 
779
  context = decl_mangling_context (decl);
780
 
781
  /* A decl in :: or ::std scope is treated specially.  The former is
782
     mangled using <unscoped-name> or <unscoped-template-name>, the
783
     latter with a special substitution.  Also, a name that is
784
     directly in a local function scope is also mangled with
785
     <unscoped-name> rather than a full <nested-name>.  */
786
  if (context == NULL
787
      || context == global_namespace
788
      || DECL_NAMESPACE_STD_P (context)
789
      || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
790
    {
791
      tree template_info;
792
      /* Is this a template instance?  */
793
      if (decl_is_template_id (decl, &template_info))
794
        {
795
          /* Yes: use <unscoped-template-name>.  */
796
          write_unscoped_template_name (TI_TEMPLATE (template_info));
797
          write_template_args (TI_ARGS (template_info));
798
        }
799
      else
800
        /* Everything else gets an <unqualified-name>.  */
801
        write_unscoped_name (decl);
802
    }
803
  else
804
    {
805
      /* Handle local names, unless we asked not to (that is, invoked
806
         under <local-name>, to handle only the part of the name under
807
         the local scope).  */
808
      if (!ignore_local_scope)
809
        {
810
          /* Scan up the list of scope context, looking for a
811
             function.  If we find one, this entity is in local
812
             function scope.  local_entity tracks context one scope
813
             level down, so it will contain the element that's
814
             directly in that function's scope, either decl or one of
815
             its enclosing scopes.  */
816
          tree local_entity = decl;
817
          while (context != NULL && context != global_namespace)
818
            {
819
              /* Make sure we're always dealing with decls.  */
820
              if (context != NULL && TYPE_P (context))
821
                context = TYPE_NAME (context);
822
              /* Is this a function?  */
823
              if (TREE_CODE (context) == FUNCTION_DECL
824
                  || TREE_CODE (context) == PARM_DECL)
825
                {
826
                  /* Yes, we have local scope.  Use the <local-name>
827
                     production for the innermost function scope.  */
828
                  write_local_name (context, local_entity, decl);
829
                  return;
830
                }
831
              /* Up one scope level.  */
832
              local_entity = context;
833
              context = decl_mangling_context (context);
834
            }
835
 
836
          /* No local scope found?  Fall through to <nested-name>.  */
837
        }
838
 
839
      /* Other decls get a <nested-name> to encode their scope.  */
840
      write_nested_name (decl);
841
    }
842
}
843
 
844
/* <unscoped-name> ::= <unqualified-name>
845
                   ::= St <unqualified-name>   # ::std::  */
846
 
847
static void
848
write_unscoped_name (const tree decl)
849
{
850
  tree context = CP_DECL_CONTEXT (decl);
851
 
852
  MANGLE_TRACE_TREE ("unscoped-name", decl);
853
 
854
  /* Is DECL in ::std?  */
855
  if (DECL_NAMESPACE_STD_P (context))
856
    {
857
      write_string ("St");
858
      write_unqualified_name (decl);
859
    }
860
  else
861
    {
862
      /* If not, it should be either in the global namespace, or directly
863
         in a local function scope.  */
864
      gcc_assert (context == global_namespace
865
                  || context != NULL
866
                  || TREE_CODE (context) == FUNCTION_DECL);
867
 
868
      write_unqualified_name (decl);
869
    }
870
}
871
 
872
/* <unscoped-template-name> ::= <unscoped-name>
873
                            ::= <substitution>  */
874
 
875
static void
876
write_unscoped_template_name (const tree decl)
877
{
878
  MANGLE_TRACE_TREE ("unscoped-template-name", decl);
879
 
880
  if (find_substitution (decl))
881
    return;
882
  write_unscoped_name (decl);
883
  add_substitution (decl);
884
}
885
 
886
/* Write the nested name, including CV-qualifiers, of DECL.
887
 
888
   <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
889
                 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
890
 
891
   <CV-qualifiers> ::= [r] [V] [K]  */
892
 
893
static void
894
write_nested_name (const tree decl)
895
{
896
  tree template_info;
897
 
898
  MANGLE_TRACE_TREE ("nested-name", decl);
899
 
900
  write_char ('N');
901
 
902
  /* Write CV-qualifiers, if this is a member function.  */
903
  if (TREE_CODE (decl) == FUNCTION_DECL
904
      && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
905
    {
906
      if (DECL_VOLATILE_MEMFUNC_P (decl))
907
        write_char ('V');
908
      if (DECL_CONST_MEMFUNC_P (decl))
909
        write_char ('K');
910
    }
911
 
912
  /* Is this a template instance?  */
913
  if (decl_is_template_id (decl, &template_info))
914
    {
915
      /* Yes, use <template-prefix>.  */
916
      write_template_prefix (decl);
917
      write_template_args (TI_ARGS (template_info));
918
    }
919
  else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
920
    {
921
      tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
922
      if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
923
        {
924
          write_template_prefix (decl);
925
          write_template_args (TREE_OPERAND (name, 1));
926
        }
927
      else
928
        {
929
          write_prefix (CP_DECL_CONTEXT (decl));
930
          write_unqualified_name (decl);
931
        }
932
    }
933
  else
934
    {
935
      /* No, just use <prefix>  */
936
      write_prefix (DECL_CONTEXT (decl));
937
      write_unqualified_name (decl);
938
    }
939
  write_char ('E');
940
}
941
 
942
/* <prefix> ::= <prefix> <unqualified-name>
943
            ::= <template-param>
944
            ::= <template-prefix> <template-args>
945
            ::= # empty
946
            ::= <substitution>  */
947
 
948
static void
949
write_prefix (const tree node)
950
{
951
  tree decl;
952
  /* Non-NULL if NODE represents a template-id.  */
953
  tree template_info = NULL;
954
 
955
  if (node == NULL
956
      || node == global_namespace)
957
    return;
958
 
959
  MANGLE_TRACE_TREE ("prefix", node);
960
 
961
  if (find_substitution (node))
962
    return;
963
 
964
  if (DECL_P (node))
965
    {
966
      /* If this is a function or parm decl, that means we've hit function
967
         scope, so this prefix must be for a local name.  In this
968
         case, we're under the <local-name> production, which encodes
969
         the enclosing function scope elsewhere.  So don't continue
970
         here.  */
971
      if (TREE_CODE (node) == FUNCTION_DECL
972
          || TREE_CODE (node) == PARM_DECL)
973
        return;
974
 
975
      decl = node;
976
      decl_is_template_id (decl, &template_info);
977
    }
978
  else
979
    {
980
      /* Node is a type.  */
981
      decl = TYPE_NAME (node);
982
      if (CLASSTYPE_TEMPLATE_ID_P (node))
983
        template_info = TYPE_TEMPLATE_INFO (node);
984
    }
985
 
986
  /* In G++ 3.2, the name of the template parameter was used.  */
987
  if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
988
      && !abi_version_at_least (2))
989
    G.need_abi_warning = true;
990
 
991
  if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
992
      && abi_version_at_least (2))
993
    write_template_param (node);
994
  else if (template_info != NULL)
995
    /* Templated.  */
996
    {
997
      write_template_prefix (decl);
998
      write_template_args (TI_ARGS (template_info));
999
    }
1000
  else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
1001
    {
1002
      tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
1003
      if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1004
        {
1005
          write_template_prefix (decl);
1006
          write_template_args (TREE_OPERAND (name, 1));
1007
        }
1008
      else
1009
        {
1010
          write_prefix (CP_DECL_CONTEXT (decl));
1011
          write_unqualified_name (decl);
1012
        }
1013
    }
1014
  else
1015
    /* Not templated.  */
1016
    {
1017
      write_prefix (decl_mangling_context (decl));
1018
      write_unqualified_name (decl);
1019
      if (TREE_CODE (decl) == VAR_DECL
1020
          || TREE_CODE (decl) == FIELD_DECL)
1021
        {
1022
          /* <data-member-prefix> := <member source-name> M */
1023
          write_char ('M');
1024
          return;
1025
        }
1026
    }
1027
 
1028
  add_substitution (node);
1029
}
1030
 
1031
/* <template-prefix> ::= <prefix> <template component>
1032
                     ::= <template-param>
1033
                     ::= <substitution>  */
1034
 
1035
static void
1036
write_template_prefix (const tree node)
1037
{
1038
  tree decl = DECL_P (node) ? node : TYPE_NAME (node);
1039
  tree type = DECL_P (node) ? TREE_TYPE (node) : node;
1040
  tree context = CP_DECL_CONTEXT (decl);
1041
  tree template_info;
1042
  tree templ;
1043
  tree substitution;
1044
 
1045
  MANGLE_TRACE_TREE ("template-prefix", node);
1046
 
1047
  /* Find the template decl.  */
1048
  if (decl_is_template_id (decl, &template_info))
1049
    templ = TI_TEMPLATE (template_info);
1050
  else if (TREE_CODE (type) == TYPENAME_TYPE)
1051
    /* For a typename type, all we have is the name.  */
1052
    templ = DECL_NAME (decl);
1053
  else
1054
    {
1055
      gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
1056
 
1057
      templ = TYPE_TI_TEMPLATE (type);
1058
    }
1059
 
1060
  /* For a member template, though, the template name for the
1061
     innermost name must have all the outer template levels
1062
     instantiated.  For instance, consider
1063
 
1064
       template<typename T> struct Outer {
1065
         template<typename U> struct Inner {};
1066
       };
1067
 
1068
     The template name for `Inner' in `Outer<int>::Inner<float>' is
1069
     `Outer<int>::Inner<U>'.  In g++, we don't instantiate the template
1070
     levels separately, so there's no TEMPLATE_DECL available for this
1071
     (there's only `Outer<T>::Inner<U>').
1072
 
1073
     In order to get the substitutions right, we create a special
1074
     TREE_LIST to represent the substitution candidate for a nested
1075
     template.  The TREE_PURPOSE is the template's context, fully
1076
     instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1077
     template.
1078
 
1079
     So, for the example above, `Outer<int>::Inner' is represented as a
1080
     substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1081
     and whose value is `Outer<T>::Inner<U>'.  */
1082
  if (TYPE_P (context))
1083
    substitution = build_tree_list (context, templ);
1084
  else
1085
    substitution = templ;
1086
 
1087
  if (find_substitution (substitution))
1088
    return;
1089
 
1090
  /* In G++ 3.2, the name of the template template parameter was used.  */
1091
  if (TREE_TYPE (templ)
1092
      && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1093
      && !abi_version_at_least (2))
1094
    G.need_abi_warning = true;
1095
 
1096
  if (TREE_TYPE (templ)
1097
      && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1098
      && abi_version_at_least (2))
1099
    write_template_param (TREE_TYPE (templ));
1100
  else
1101
    {
1102
      write_prefix (context);
1103
      write_unqualified_name (decl);
1104
    }
1105
 
1106
  add_substitution (substitution);
1107
}
1108
 
1109
/* We don't need to handle thunks, vtables, or VTTs here.  Those are
1110
   mangled through special entry points.
1111
 
1112
    <unqualified-name>  ::= <operator-name>
1113
                        ::= <special-name>
1114
                        ::= <source-name>
1115
                        ::= <unnamed-type-name>
1116
                        ::= <local-source-name>
1117
 
1118
    <local-source-name> ::= L <source-name> <discriminator> */
1119
 
1120
static void
1121
write_unqualified_id (tree identifier)
1122
{
1123
  if (IDENTIFIER_TYPENAME_P (identifier))
1124
    write_conversion_operator_name (TREE_TYPE (identifier));
1125
  else if (IDENTIFIER_OPNAME_P (identifier))
1126
    {
1127
      int i;
1128
      const char *mangled_name = NULL;
1129
 
1130
      /* Unfortunately, there is no easy way to go from the
1131
         name of the operator back to the corresponding tree
1132
         code.  */
1133
      for (i = 0; i < MAX_TREE_CODES; ++i)
1134
        if (operator_name_info[i].identifier == identifier)
1135
          {
1136
            /* The ABI says that we prefer binary operator
1137
               names to unary operator names.  */
1138
            if (operator_name_info[i].arity == 2)
1139
              {
1140
                mangled_name = operator_name_info[i].mangled_name;
1141
                break;
1142
              }
1143
            else if (!mangled_name)
1144
              mangled_name = operator_name_info[i].mangled_name;
1145
          }
1146
        else if (assignment_operator_name_info[i].identifier
1147
                 == identifier)
1148
          {
1149
            mangled_name
1150
              = assignment_operator_name_info[i].mangled_name;
1151
            break;
1152
          }
1153
      write_string (mangled_name);
1154
    }
1155
  else
1156
    write_source_name (identifier);
1157
}
1158
 
1159
static void
1160
write_unqualified_name (const tree decl)
1161
{
1162
  MANGLE_TRACE_TREE ("unqualified-name", decl);
1163
 
1164
  if (TREE_CODE (decl) == IDENTIFIER_NODE)
1165
    {
1166
      write_unqualified_id (decl);
1167
      return;
1168
    }
1169
 
1170
  if (DECL_NAME (decl) == NULL_TREE)
1171
    {
1172
      gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1173
      write_source_name (DECL_ASSEMBLER_NAME (decl));
1174
      return;
1175
    }
1176
  else if (DECL_DECLARES_FUNCTION_P (decl))
1177
    {
1178
      bool found = true;
1179
      if (DECL_CONSTRUCTOR_P (decl))
1180
        write_special_name_constructor (decl);
1181
      else if (DECL_DESTRUCTOR_P (decl))
1182
        write_special_name_destructor (decl);
1183
      else if (DECL_CONV_FN_P (decl))
1184
        {
1185
          /* Conversion operator. Handle it right here.
1186
             <operator> ::= cv <type>  */
1187
          tree type;
1188
          if (decl_is_template_id (decl, NULL))
1189
            {
1190
              tree fn_type;
1191
              fn_type = get_mostly_instantiated_function_type (decl);
1192
              type = TREE_TYPE (fn_type);
1193
            }
1194
          else
1195
            type = DECL_CONV_FN_TYPE (decl);
1196
          write_conversion_operator_name (type);
1197
        }
1198
      else if (DECL_OVERLOADED_OPERATOR_P (decl))
1199
        {
1200
          operator_name_info_t *oni;
1201
          if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1202
            oni = assignment_operator_name_info;
1203
          else
1204
            oni = operator_name_info;
1205
 
1206
          write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1207
        }
1208
      else
1209
        found = false;
1210
 
1211
      if (found)
1212
        return;
1213
    }
1214
 
1215
  if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1216
      && DECL_NAMESPACE_SCOPE_P (decl)
1217
      && decl_linkage (decl) == lk_internal)
1218
    {
1219
      MANGLE_TRACE_TREE ("local-source-name", decl);
1220
      write_char ('L');
1221
      write_source_name (DECL_NAME (decl));
1222
      /* The default discriminator is 1, and that's all we ever use,
1223
         so there's no code to output one here.  */
1224
    }
1225
  else
1226
    {
1227
      tree type = TREE_TYPE (decl);
1228
 
1229
      if (TREE_CODE (decl) == TYPE_DECL
1230
          && TYPE_ANONYMOUS_P (type))
1231
        write_unnamed_type_name (type);
1232
      else if (TREE_CODE (decl) == TYPE_DECL
1233
               && LAMBDA_TYPE_P (type))
1234
        write_closure_type_name (type);
1235
      else
1236
        write_source_name (DECL_NAME (decl));
1237
    }
1238
}
1239
 
1240
/* Write the unqualified-name for a conversion operator to TYPE.  */
1241
 
1242
static void
1243
write_conversion_operator_name (const tree type)
1244
{
1245
  write_string ("cv");
1246
  write_type (type);
1247
}
1248
 
1249
/* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1250
 
1251
     <source-name> ::= </length/ number> <identifier>  */
1252
 
1253
static void
1254
write_source_name (tree identifier)
1255
{
1256
  MANGLE_TRACE_TREE ("source-name", identifier);
1257
 
1258
  /* Never write the whole template-id name including the template
1259
     arguments; we only want the template name.  */
1260
  if (IDENTIFIER_TEMPLATE (identifier))
1261
    identifier = IDENTIFIER_TEMPLATE (identifier);
1262
 
1263
  write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1264
  write_identifier (IDENTIFIER_POINTER (identifier));
1265
}
1266
 
1267
/* Encode 0 as _, and 1+ as n-1_.  */
1268
 
1269
static void
1270
write_compact_number (int num)
1271
{
1272
  if (num > 0)
1273
    write_unsigned_number (num - 1);
1274
  write_char ('_');
1275
}
1276
 
1277
/* Return how many unnamed types precede TYPE in its enclosing class.  */
1278
 
1279
static int
1280
nested_anon_class_index (tree type)
1281
{
1282
  int index = 0;
1283
  tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
1284
  for (; member; member = TREE_CHAIN (member))
1285
    if (DECL_IMPLICIT_TYPEDEF_P (member))
1286
      {
1287
        tree memtype = TREE_TYPE (member);
1288
        if (memtype == type)
1289
          return index;
1290
        else if (TYPE_ANONYMOUS_P (memtype))
1291
          ++index;
1292
      }
1293
 
1294
  gcc_unreachable ();
1295
}
1296
 
1297
/* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1298
 
1299
static void
1300
write_unnamed_type_name (const tree type __attribute__ ((__unused__)))
1301
{
1302
  int discriminator;
1303
  MANGLE_TRACE_TREE ("unnamed-type-name", type);
1304
 
1305
  if (TYPE_FUNCTION_SCOPE_P (type))
1306
    discriminator = local_class_index (type);
1307
  else if (TYPE_CLASS_SCOPE_P (type))
1308
    discriminator = nested_anon_class_index (type);
1309
  else
1310
    {
1311
      gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1312
      /* Just use the old mangling at namespace scope.  */
1313
      write_source_name (TYPE_IDENTIFIER (type));
1314
      return;
1315
    }
1316
 
1317
  write_string ("Ut");
1318
  write_compact_number (discriminator);
1319
}
1320
 
1321
/* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1322
   <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
1323
 
1324
static void
1325
write_closure_type_name (const tree type)
1326
{
1327
  tree fn = lambda_function (type);
1328
  tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
1329
  tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
1330
 
1331
  MANGLE_TRACE_TREE ("closure-type-name", type);
1332
 
1333
  write_string ("Ul");
1334
  write_method_parms (parms, /*method_p=*/1, fn);
1335
  write_char ('E');
1336
  write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
1337
}
1338
 
1339
/* Convert NUMBER to ascii using base BASE and generating at least
1340
   MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1341
   into which to store the characters. Returns the number of
1342
   characters generated (these will be layed out in advance of where
1343
   BUFFER points).  */
1344
 
1345
static int
1346
hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1347
                char *buffer, const unsigned int min_digits)
1348
{
1349
  static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1350
  unsigned digits = 0;
1351
 
1352
  while (number)
1353
    {
1354
      unsigned HOST_WIDE_INT d = number / base;
1355
 
1356
      *--buffer = base_digits[number - d * base];
1357
      digits++;
1358
      number = d;
1359
    }
1360
  while (digits < min_digits)
1361
    {
1362
      *--buffer = base_digits[0];
1363
      digits++;
1364
    }
1365
  return digits;
1366
}
1367
 
1368
/* Non-terminal <number>.
1369
 
1370
     <number> ::= [n] </decimal integer/>  */
1371
 
1372
static void
1373
write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1374
              const unsigned int base)
1375
{
1376
  char buffer[sizeof (HOST_WIDE_INT) * 8];
1377
  unsigned count = 0;
1378
 
1379
  if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1380
    {
1381
      write_char ('n');
1382
      number = -((HOST_WIDE_INT) number);
1383
    }
1384
  count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1385
  write_chars (buffer + sizeof (buffer) - count, count);
1386
}
1387
 
1388
/* Write out an integral CST in decimal. Most numbers are small, and
1389
   representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1390
   bigger than that, which we must deal with.  */
1391
 
1392
static inline void
1393
write_integer_cst (const tree cst)
1394
{
1395
  int sign = tree_int_cst_sgn (cst);
1396
 
1397
  if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1398
    {
1399
      /* A bignum. We do this in chunks, each of which fits in a
1400
         HOST_WIDE_INT.  */
1401
      char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1402
      unsigned HOST_WIDE_INT chunk;
1403
      unsigned chunk_digits;
1404
      char *ptr = buffer + sizeof (buffer);
1405
      unsigned count = 0;
1406
      tree n, base, type;
1407
      int done;
1408
 
1409
      /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1410
         representable.  */
1411
      chunk = 1000000000;
1412
      chunk_digits = 9;
1413
 
1414
      if (sizeof (HOST_WIDE_INT) >= 8)
1415
        {
1416
          /* It is at least 64 bits, so 10^18 is representable.  */
1417
          chunk_digits = 18;
1418
          chunk *= chunk;
1419
        }
1420
 
1421
      type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1422
      base = build_int_cstu (type, chunk);
1423
      n = build_int_cst_wide (type,
1424
                              TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1425
 
1426
      if (sign < 0)
1427
        {
1428
          write_char ('n');
1429
          n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1430
        }
1431
      do
1432
        {
1433
          tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1434
          tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1435
          unsigned c;
1436
 
1437
          done = integer_zerop (d);
1438
          tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1439
          c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1440
                              done ? 1 : chunk_digits);
1441
          ptr -= c;
1442
          count += c;
1443
          n = d;
1444
        }
1445
      while (!done);
1446
      write_chars (ptr, count);
1447
    }
1448
  else
1449
    {
1450
      /* A small num.  */
1451
      unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1452
 
1453
      if (sign < 0)
1454
        {
1455
          write_char ('n');
1456
          low = -low;
1457
        }
1458
      write_unsigned_number (low);
1459
    }
1460
}
1461
 
1462
/* Write out a floating-point literal.
1463
 
1464
    "Floating-point literals are encoded using the bit pattern of the
1465
    target processor's internal representation of that number, as a
1466
    fixed-length lowercase hexadecimal string, high-order bytes first
1467
    (even if the target processor would store low-order bytes first).
1468
    The "n" prefix is not used for floating-point literals; the sign
1469
    bit is encoded with the rest of the number.
1470
 
1471
    Here are some examples, assuming the IEEE standard representation
1472
    for floating point numbers.  (Spaces are for readability, not
1473
    part of the encoding.)
1474
 
1475
        1.0f                    Lf 3f80 0000 E
1476
       -1.0f                    Lf bf80 0000 E
1477
        1.17549435e-38f         Lf 0080 0000 E
1478
        1.40129846e-45f         Lf 0000 0001 E
1479
        0.0f                    Lf 0000 0000 E"
1480
 
1481
   Caller is responsible for the Lx and the E.  */
1482
static void
1483
write_real_cst (const tree value)
1484
{
1485
  if (abi_version_at_least (2))
1486
    {
1487
      long target_real[4];  /* largest supported float */
1488
      char buffer[9];       /* eight hex digits in a 32-bit number */
1489
      int i, limit, dir;
1490
 
1491
      tree type = TREE_TYPE (value);
1492
      int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1493
 
1494
      real_to_target (target_real, &TREE_REAL_CST (value),
1495
                      TYPE_MODE (type));
1496
 
1497
      /* The value in target_real is in the target word order,
1498
         so we must write it out backward if that happens to be
1499
         little-endian.  write_number cannot be used, it will
1500
         produce uppercase.  */
1501
      if (FLOAT_WORDS_BIG_ENDIAN)
1502
        i = 0, limit = words, dir = 1;
1503
      else
1504
        i = words - 1, limit = -1, dir = -1;
1505
 
1506
      for (; i != limit; i += dir)
1507
        {
1508
          sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1509
          write_chars (buffer, 8);
1510
        }
1511
    }
1512
  else
1513
    {
1514
      /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1515
         literally.  Note that compatibility with 3.2 is impossible,
1516
         because the old floating-point emulator used a different
1517
         format for REAL_VALUE_TYPE.  */
1518
      size_t i;
1519
      for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1520
        write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1521
                      /*unsigned_p*/ 1,
1522
                      /*base*/ 16);
1523
      G.need_abi_warning = 1;
1524
    }
1525
}
1526
 
1527
/* Non-terminal <identifier>.
1528
 
1529
     <identifier> ::= </unqualified source code identifier>  */
1530
 
1531
static void
1532
write_identifier (const char *identifier)
1533
{
1534
  MANGLE_TRACE ("identifier", identifier);
1535
  write_string (identifier);
1536
}
1537
 
1538
/* Handle constructor productions of non-terminal <special-name>.
1539
   CTOR is a constructor FUNCTION_DECL.
1540
 
1541
     <special-name> ::= C1   # complete object constructor
1542
                    ::= C2   # base object constructor
1543
                    ::= C3   # complete object allocating constructor
1544
 
1545
   Currently, allocating constructors are never used.
1546
 
1547
   We also need to provide mangled names for the maybe-in-charge
1548
   constructor, so we treat it here too.  mangle_decl_string will
1549
   append *INTERNAL* to that, to make sure we never emit it.  */
1550
 
1551
static void
1552
write_special_name_constructor (const tree ctor)
1553
{
1554
  if (DECL_BASE_CONSTRUCTOR_P (ctor))
1555
    write_string ("C2");
1556
  else
1557
    {
1558
      gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1559
                  /* Even though we don't ever emit a definition of
1560
                     the old-style destructor, we still have to
1561
                     consider entities (like static variables) nested
1562
                     inside it.  */
1563
                  || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor));
1564
      write_string ("C1");
1565
    }
1566
}
1567
 
1568
/* Handle destructor productions of non-terminal <special-name>.
1569
   DTOR is a destructor FUNCTION_DECL.
1570
 
1571
     <special-name> ::= D0 # deleting (in-charge) destructor
1572
                    ::= D1 # complete object (in-charge) destructor
1573
                    ::= D2 # base object (not-in-charge) destructor
1574
 
1575
   We also need to provide mangled names for the maybe-incharge
1576
   destructor, so we treat it here too.  mangle_decl_string will
1577
   append *INTERNAL* to that, to make sure we never emit it.  */
1578
 
1579
static void
1580
write_special_name_destructor (const tree dtor)
1581
{
1582
  if (DECL_DELETING_DESTRUCTOR_P (dtor))
1583
    write_string ("D0");
1584
  else if (DECL_BASE_DESTRUCTOR_P (dtor))
1585
    write_string ("D2");
1586
  else
1587
    {
1588
      gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1589
                  /* Even though we don't ever emit a definition of
1590
                     the old-style destructor, we still have to
1591
                     consider entities (like static variables) nested
1592
                     inside it.  */
1593
                  || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor));
1594
      write_string ("D1");
1595
    }
1596
}
1597
 
1598
/* Scan the vector of local classes and return how many others with the
1599
   same name (or same no name) and context precede ENTITY.  */
1600
 
1601
static int
1602
local_class_index (tree entity)
1603
{
1604
  int ix, discriminator = 0;
1605
  tree name = (TYPE_ANONYMOUS_P (entity) ? NULL_TREE
1606
               : TYPE_IDENTIFIER (entity));
1607
  tree ctx = TYPE_CONTEXT (entity);
1608
  for (ix = 0; ; ix++)
1609
    {
1610
      tree type = VEC_index (tree, local_classes, ix);
1611
      if (type == entity)
1612
        return discriminator;
1613
      if (TYPE_CONTEXT (type) == ctx
1614
          && (name ? TYPE_IDENTIFIER (type) == name
1615
              : TYPE_ANONYMOUS_P (type)))
1616
        ++discriminator;
1617
    }
1618
  gcc_unreachable ();
1619
}
1620
 
1621
/* Return the discriminator for ENTITY appearing inside
1622
   FUNCTION.  The discriminator is the lexical ordinal of VAR among
1623
   entities with the same name in the same FUNCTION.  */
1624
 
1625
static int
1626
discriminator_for_local_entity (tree entity)
1627
{
1628
  if (DECL_DISCRIMINATOR_P (entity))
1629
    {
1630
      if (DECL_DISCRIMINATOR_SET_P (entity))
1631
        return DECL_DISCRIMINATOR (entity);
1632
      else
1633
        /* The first entity with a particular name doesn't get
1634
           DECL_DISCRIMINATOR set up.  */
1635
        return 0;
1636
    }
1637
  else if (TREE_CODE (entity) == TYPE_DECL)
1638
    {
1639
      /* Scan the list of local classes.  */
1640
      entity = TREE_TYPE (entity);
1641
 
1642
      /* Lambdas and unnamed types have their own discriminators.  */
1643
      if (LAMBDA_TYPE_P (entity) || TYPE_ANONYMOUS_P (entity))
1644
        return 0;
1645
 
1646
      return local_class_index (entity);
1647
    }
1648
  else
1649
    gcc_unreachable ();
1650
}
1651
 
1652
/* Return the discriminator for STRING, a string literal used inside
1653
   FUNCTION.  The discriminator is the lexical ordinal of STRING among
1654
   string literals used in FUNCTION.  */
1655
 
1656
static int
1657
discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1658
                                  tree string ATTRIBUTE_UNUSED)
1659
{
1660
  /* For now, we don't discriminate amongst string literals.  */
1661
  return 0;
1662
}
1663
 
1664
/*   <discriminator> := _ <number>
1665
 
1666
   The discriminator is used only for the second and later occurrences
1667
   of the same name within a single function. In this case <number> is
1668
   n - 2, if this is the nth occurrence, in lexical order.  */
1669
 
1670
static void
1671
write_discriminator (const int discriminator)
1672
{
1673
  /* If discriminator is zero, don't write anything.  Otherwise...  */
1674
  if (discriminator > 0)
1675
    {
1676
      write_char ('_');
1677
      write_unsigned_number (discriminator - 1);
1678
    }
1679
}
1680
 
1681
/* Mangle the name of a function-scope entity.  FUNCTION is the
1682
   FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1683
   default argument scope.  ENTITY is the decl for the entity itself.
1684
   LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1685
   either ENTITY itself or an enclosing scope of ENTITY.
1686
 
1687
     <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1688
                  := Z <function encoding> E s [<discriminator>]
1689
                  := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1690
 
1691
static void
1692
write_local_name (tree function, const tree local_entity,
1693
                  const tree entity)
1694
{
1695
  tree parm = NULL_TREE;
1696
 
1697
  MANGLE_TRACE_TREE ("local-name", entity);
1698
 
1699
  if (TREE_CODE (function) == PARM_DECL)
1700
    {
1701
      parm = function;
1702
      function = DECL_CONTEXT (parm);
1703
    }
1704
 
1705
  write_char ('Z');
1706
  write_encoding (function);
1707
  write_char ('E');
1708
 
1709
  /* For this purpose, parameters are numbered from right-to-left.  */
1710
  if (parm)
1711
    {
1712
      tree t;
1713
      int i = 0;
1714
      for (t = DECL_ARGUMENTS (function); t; t = TREE_CHAIN (t))
1715
        {
1716
          if (t == parm)
1717
            i = 1;
1718
          else if (i)
1719
            ++i;
1720
        }
1721
      write_char ('d');
1722
      write_compact_number (i - 1);
1723
    }
1724
 
1725
  if (TREE_CODE (entity) == STRING_CST)
1726
    {
1727
      write_char ('s');
1728
      write_discriminator (discriminator_for_string_literal (function,
1729
                                                             entity));
1730
    }
1731
  else
1732
    {
1733
      /* Now the <entity name>.  Let write_name know its being called
1734
         from <local-name>, so it doesn't try to process the enclosing
1735
         function scope again.  */
1736
      write_name (entity, /*ignore_local_scope=*/1);
1737
      write_discriminator (discriminator_for_local_entity (local_entity));
1738
    }
1739
}
1740
 
1741
/* Non-terminals <type> and <CV-qualifier>.
1742
 
1743
     <type> ::= <builtin-type>
1744
            ::= <function-type>
1745
            ::= <class-enum-type>
1746
            ::= <array-type>
1747
            ::= <pointer-to-member-type>
1748
            ::= <template-param>
1749
            ::= <substitution>
1750
            ::= <CV-qualifier>
1751
            ::= P <type>    # pointer-to
1752
            ::= R <type>    # reference-to
1753
            ::= C <type>    # complex pair (C 2000)
1754
            ::= G <type>    # imaginary (C 2000)     [not supported]
1755
            ::= U <source-name> <type>   # vendor extended type qualifier
1756
 
1757
   C++0x extensions
1758
 
1759
     <type> ::= RR <type>   # rvalue reference-to
1760
     <type> ::= Dt <expression> # decltype of an id-expression or
1761
                                # class member access
1762
     <type> ::= DT <expression> # decltype of an expression
1763
 
1764
   TYPE is a type node.  */
1765
 
1766
static void
1767
write_type (tree type)
1768
{
1769
  /* This gets set to nonzero if TYPE turns out to be a (possibly
1770
     CV-qualified) builtin type.  */
1771
  int is_builtin_type = 0;
1772
 
1773
  MANGLE_TRACE_TREE ("type", type);
1774
 
1775
  if (type == error_mark_node)
1776
    return;
1777
 
1778
  if (find_substitution (type))
1779
    return;
1780
 
1781
  /* According to the C++ ABI, some library classes are passed the
1782
     same as the scalar type of their single member and use the same
1783
     mangling.  */
1784
  if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
1785
    type = TREE_TYPE (first_field (type));
1786
 
1787
  if (write_CV_qualifiers_for_type (type) > 0)
1788
    /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1789
       mangle the unqualified type.  The recursive call is needed here
1790
       since both the qualified and unqualified types are substitution
1791
       candidates.  */
1792
    write_type (TYPE_MAIN_VARIANT (type));
1793
  else if (TREE_CODE (type) == ARRAY_TYPE)
1794
    /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1795
       so that the cv-qualification of the element type is available
1796
       in write_array_type.  */
1797
    write_array_type (type);
1798
  else
1799
    {
1800
      tree type_orig = type;
1801
 
1802
      /* See through any typedefs.  */
1803
      type = TYPE_MAIN_VARIANT (type);
1804
 
1805
      if (TYPE_PTRMEM_P (type))
1806
        write_pointer_to_member_type (type);
1807
      else
1808
        {
1809
          /* Handle any target-specific fundamental types.  */
1810
          const char *target_mangling
1811
            = targetm.mangle_type (type_orig);
1812
 
1813
          if (target_mangling)
1814
            {
1815
              write_string (target_mangling);
1816
              /* Add substitutions for types other than fundamental
1817
                 types.  */
1818
              if (TREE_CODE (type) != VOID_TYPE
1819
                  && TREE_CODE (type) != INTEGER_TYPE
1820
                  && TREE_CODE (type) != REAL_TYPE
1821
                  && TREE_CODE (type) != BOOLEAN_TYPE)
1822
                add_substitution (type);
1823
              return;
1824
            }
1825
 
1826
          switch (TREE_CODE (type))
1827
            {
1828
            case VOID_TYPE:
1829
            case BOOLEAN_TYPE:
1830
            case INTEGER_TYPE:  /* Includes wchar_t.  */
1831
            case REAL_TYPE:
1832
            case FIXED_POINT_TYPE:
1833
              {
1834
                /* If this is a typedef, TYPE may not be one of
1835
                   the standard builtin type nodes, but an alias of one.  Use
1836
                   TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
1837
                write_builtin_type (TYPE_MAIN_VARIANT (type));
1838
                ++is_builtin_type;
1839
              }
1840
              break;
1841
 
1842
            case COMPLEX_TYPE:
1843
              write_char ('C');
1844
              write_type (TREE_TYPE (type));
1845
              break;
1846
 
1847
            case FUNCTION_TYPE:
1848
            case METHOD_TYPE:
1849
              write_function_type (type);
1850
              break;
1851
 
1852
            case UNION_TYPE:
1853
            case RECORD_TYPE:
1854
            case ENUMERAL_TYPE:
1855
              /* A pointer-to-member function is represented as a special
1856
                 RECORD_TYPE, so check for this first.  */
1857
              if (TYPE_PTRMEMFUNC_P (type))
1858
                write_pointer_to_member_type (type);
1859
              else
1860
                write_class_enum_type (type);
1861
              break;
1862
 
1863
            case TYPENAME_TYPE:
1864
            case UNBOUND_CLASS_TEMPLATE:
1865
              /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1866
                 ordinary nested names.  */
1867
              write_nested_name (TYPE_STUB_DECL (type));
1868
              break;
1869
 
1870
            case POINTER_TYPE:
1871
              write_char ('P');
1872
              write_type (TREE_TYPE (type));
1873
              break;
1874
 
1875
            case REFERENCE_TYPE:
1876
              if (TYPE_REF_IS_RVALUE (type))
1877
                write_char('O');
1878
              else
1879
                write_char ('R');
1880
              write_type (TREE_TYPE (type));
1881
              break;
1882
 
1883
            case TEMPLATE_TYPE_PARM:
1884
            case TEMPLATE_PARM_INDEX:
1885
              write_template_param (type);
1886
              break;
1887
 
1888
            case TEMPLATE_TEMPLATE_PARM:
1889
              write_template_template_param (type);
1890
              break;
1891
 
1892
            case BOUND_TEMPLATE_TEMPLATE_PARM:
1893
              write_template_template_param (type);
1894
              write_template_args
1895
                (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1896
              break;
1897
 
1898
            case VECTOR_TYPE:
1899
              if (abi_version_at_least (4))
1900
                {
1901
                  write_string ("Dv");
1902
                  /* Non-constant vector size would be encoded with
1903
                     _ expression, but we don't support that yet.  */
1904
                  write_unsigned_number (TYPE_VECTOR_SUBPARTS (type));
1905
                  write_char ('_');
1906
                }
1907
              else
1908
                {
1909
                  G.need_abi_warning = 1;
1910
                  write_string ("U8__vector");
1911
                }
1912
              write_type (TREE_TYPE (type));
1913
              break;
1914
 
1915
            case TYPE_PACK_EXPANSION:
1916
              write_string ("Dp");
1917
              write_type (PACK_EXPANSION_PATTERN (type));
1918
              break;
1919
 
1920
            case DECLTYPE_TYPE:
1921
              /* These shouldn't make it into mangling.  */
1922
              gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
1923
                          && !DECLTYPE_FOR_LAMBDA_RETURN (type));
1924
 
1925
              write_char ('D');
1926
              if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
1927
                write_char ('t');
1928
              else
1929
                write_char ('T');
1930
              ++cp_unevaluated_operand;
1931
              write_expression (DECLTYPE_TYPE_EXPR (type));
1932
              --cp_unevaluated_operand;
1933
              write_char ('E');
1934
              break;
1935
 
1936
            case TYPEOF_TYPE:
1937
              sorry ("mangling typeof, use decltype instead");
1938
              break;
1939
 
1940
            default:
1941
              gcc_unreachable ();
1942
            }
1943
        }
1944
    }
1945
 
1946
  /* Types other than builtin types are substitution candidates.  */
1947
  if (!is_builtin_type)
1948
    add_substitution (type);
1949
}
1950
 
1951
/* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
1952
   CV-qualifiers written for TYPE.
1953
 
1954
     <CV-qualifiers> ::= [r] [V] [K]  */
1955
 
1956
static int
1957
write_CV_qualifiers_for_type (const tree type)
1958
{
1959
  int num_qualifiers = 0;
1960
 
1961
  /* The order is specified by:
1962
 
1963
       "In cases where multiple order-insensitive qualifiers are
1964
       present, they should be ordered 'K' (closest to the base type),
1965
       'V', 'r', and 'U' (farthest from the base type) ..."
1966
 
1967
     Note that we do not use cp_type_quals below; given "const
1968
     int[3]", the "const" is emitted with the "int", not with the
1969
     array.  */
1970
 
1971
  if (TYPE_QUALS (type) & TYPE_QUAL_RESTRICT)
1972
    {
1973
      write_char ('r');
1974
      ++num_qualifiers;
1975
    }
1976
  if (TYPE_QUALS (type) & TYPE_QUAL_VOLATILE)
1977
    {
1978
      write_char ('V');
1979
      ++num_qualifiers;
1980
    }
1981
  if (TYPE_QUALS (type) & TYPE_QUAL_CONST)
1982
    {
1983
      write_char ('K');
1984
      ++num_qualifiers;
1985
    }
1986
 
1987
  return num_qualifiers;
1988
}
1989
 
1990
/* Non-terminal <builtin-type>.
1991
 
1992
     <builtin-type> ::= v   # void
1993
                    ::= b   # bool
1994
                    ::= w   # wchar_t
1995
                    ::= c   # char
1996
                    ::= a   # signed char
1997
                    ::= h   # unsigned char
1998
                    ::= s   # short
1999
                    ::= t   # unsigned short
2000
                    ::= i   # int
2001
                    ::= j   # unsigned int
2002
                    ::= l   # long
2003
                    ::= m   # unsigned long
2004
                    ::= x   # long long, __int64
2005
                    ::= y   # unsigned long long, __int64
2006
                    ::= n   # __int128
2007
                    ::= o   # unsigned __int128
2008
                    ::= f   # float
2009
                    ::= d   # double
2010
                    ::= e   # long double, __float80
2011
                    ::= g   # __float128          [not supported]
2012
                    ::= u <source-name>  # vendor extended type */
2013
 
2014
static void
2015
write_builtin_type (tree type)
2016
{
2017
  if (TYPE_CANONICAL (type))
2018
    type = TYPE_CANONICAL (type);
2019
 
2020
  switch (TREE_CODE (type))
2021
    {
2022
    case VOID_TYPE:
2023
      write_char ('v');
2024
      break;
2025
 
2026
    case BOOLEAN_TYPE:
2027
      write_char ('b');
2028
      break;
2029
 
2030
    case INTEGER_TYPE:
2031
      /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2032
         isn't in integer_type_nodes.  */
2033
      if (type == wchar_type_node)
2034
        write_char ('w');
2035
      else if (type == char16_type_node)
2036
        write_string ("Ds");
2037
      else if (type == char32_type_node)
2038
        write_string ("Di");
2039
      else if (TYPE_FOR_JAVA (type))
2040
        write_java_integer_type_codes (type);
2041
      else
2042
        {
2043
          size_t itk;
2044
          /* Assume TYPE is one of the shared integer type nodes.  Find
2045
             it in the array of these nodes.  */
2046
        iagain:
2047
          for (itk = 0; itk < itk_none; ++itk)
2048
            if (type == integer_types[itk])
2049
              {
2050
                /* Print the corresponding single-letter code.  */
2051
                write_char (integer_type_codes[itk]);
2052
                break;
2053
              }
2054
 
2055
          if (itk == itk_none)
2056
            {
2057
              tree t = c_common_type_for_mode (TYPE_MODE (type),
2058
                                               TYPE_UNSIGNED (type));
2059
              if (type != t)
2060
                {
2061
                  type = t;
2062
                  goto iagain;
2063
                }
2064
 
2065
              if (TYPE_PRECISION (type) == 128)
2066
                write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2067
              else
2068
                {
2069
                  /* Allow for cases where TYPE is not one of the shared
2070
                     integer type nodes and write a "vendor extended builtin
2071
                     type" with a name the form intN or uintN, respectively.
2072
                     Situations like this can happen if you have an
2073
                     __attribute__((__mode__(__SI__))) type and use exotic
2074
                     switches like '-mint8' on AVR.  Of course, this is
2075
                     undefined by the C++ ABI (and '-mint8' is not even
2076
                     Standard C conforming), but when using such special
2077
                     options you're pretty much in nowhere land anyway.  */
2078
                  const char *prefix;
2079
                  char prec[11];        /* up to ten digits for an unsigned */
2080
 
2081
                  prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2082
                  sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2083
                  write_char ('u');     /* "vendor extended builtin type" */
2084
                  write_unsigned_number (strlen (prefix) + strlen (prec));
2085
                  write_string (prefix);
2086
                  write_string (prec);
2087
                }
2088
            }
2089
        }
2090
      break;
2091
 
2092
    case REAL_TYPE:
2093
      if (type == float_type_node
2094
          || type == java_float_type_node)
2095
        write_char ('f');
2096
      else if (type == double_type_node
2097
               || type == java_double_type_node)
2098
        write_char ('d');
2099
      else if (type == long_double_type_node)
2100
        write_char ('e');
2101
      else if (type == dfloat32_type_node)
2102
        write_string ("Df");
2103
      else if (type == dfloat64_type_node)
2104
        write_string ("Dd");
2105
      else if (type == dfloat128_type_node)
2106
        write_string ("De");
2107
      else
2108
        gcc_unreachable ();
2109
      break;
2110
 
2111
    case FIXED_POINT_TYPE:
2112
      write_string ("DF");
2113
      if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2114
        write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2115
      if (type == fract_type_node
2116
          || type == sat_fract_type_node
2117
          || type == accum_type_node
2118
          || type == sat_accum_type_node)
2119
        write_char ('i');
2120
      else if (type == unsigned_fract_type_node
2121
               || type == sat_unsigned_fract_type_node
2122
               || type == unsigned_accum_type_node
2123
               || type == sat_unsigned_accum_type_node)
2124
        write_char ('j');
2125
      else if (type == short_fract_type_node
2126
               || type == sat_short_fract_type_node
2127
               || type == short_accum_type_node
2128
               || type == sat_short_accum_type_node)
2129
        write_char ('s');
2130
      else if (type == unsigned_short_fract_type_node
2131
               || type == sat_unsigned_short_fract_type_node
2132
               || type == unsigned_short_accum_type_node
2133
               || type == sat_unsigned_short_accum_type_node)
2134
        write_char ('t');
2135
      else if (type == long_fract_type_node
2136
               || type == sat_long_fract_type_node
2137
               || type == long_accum_type_node
2138
               || type == sat_long_accum_type_node)
2139
        write_char ('l');
2140
      else if (type == unsigned_long_fract_type_node
2141
               || type == sat_unsigned_long_fract_type_node
2142
               || type == unsigned_long_accum_type_node
2143
               || type == sat_unsigned_long_accum_type_node)
2144
        write_char ('m');
2145
      else if (type == long_long_fract_type_node
2146
               || type == sat_long_long_fract_type_node
2147
               || type == long_long_accum_type_node
2148
               || type == sat_long_long_accum_type_node)
2149
        write_char ('x');
2150
      else if (type == unsigned_long_long_fract_type_node
2151
               || type == sat_unsigned_long_long_fract_type_node
2152
               || type == unsigned_long_long_accum_type_node
2153
               || type == sat_unsigned_long_long_accum_type_node)
2154
        write_char ('y');
2155
      else
2156
        sorry ("mangling unknown fixed point type");
2157
      write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2158
      if (TYPE_SATURATING (type))
2159
        write_char ('s');
2160
      else
2161
        write_char ('n');
2162
      break;
2163
 
2164
    default:
2165
      gcc_unreachable ();
2166
    }
2167
}
2168
 
2169
/* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2170
   METHOD_TYPE.  The return type is mangled before the parameter
2171
   types.
2172
 
2173
     <function-type> ::= F [Y] <bare-function-type> E   */
2174
 
2175
static void
2176
write_function_type (const tree type)
2177
{
2178
  MANGLE_TRACE_TREE ("function-type", type);
2179
 
2180
  /* For a pointer to member function, the function type may have
2181
     cv-qualifiers, indicating the quals for the artificial 'this'
2182
     parameter.  */
2183
  if (TREE_CODE (type) == METHOD_TYPE)
2184
    {
2185
      /* The first parameter must be a POINTER_TYPE pointing to the
2186
         `this' parameter.  */
2187
      tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
2188
      write_CV_qualifiers_for_type (this_type);
2189
    }
2190
 
2191
  write_char ('F');
2192
  /* We don't track whether or not a type is `extern "C"'.  Note that
2193
     you can have an `extern "C"' function that does not have
2194
     `extern "C"' type, and vice versa:
2195
 
2196
       extern "C" typedef void function_t();
2197
       function_t f; // f has C++ linkage, but its type is
2198
                     // `extern "C"'
2199
 
2200
       typedef void function_t();
2201
       extern "C" function_t f; // Vice versa.
2202
 
2203
     See [dcl.link].  */
2204
  write_bare_function_type (type, /*include_return_type_p=*/1,
2205
                            /*decl=*/NULL);
2206
  write_char ('E');
2207
}
2208
 
2209
/* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2210
   METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2211
   is mangled before the parameter types.  If non-NULL, DECL is
2212
   FUNCTION_DECL for the function whose type is being emitted.
2213
 
2214
   If DECL is a member of a Java type, then a literal 'J'
2215
   is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2216
   were nonzero.
2217
 
2218
     <bare-function-type> ::= [J]</signature/ type>+  */
2219
 
2220
static void
2221
write_bare_function_type (const tree type, const int include_return_type_p,
2222
                          const tree decl)
2223
{
2224
  int java_method_p;
2225
 
2226
  MANGLE_TRACE_TREE ("bare-function-type", type);
2227
 
2228
  /* Detect Java methods and emit special encoding.  */
2229
  if (decl != NULL
2230
      && DECL_FUNCTION_MEMBER_P (decl)
2231
      && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
2232
      && !DECL_CONSTRUCTOR_P (decl)
2233
      && !DECL_DESTRUCTOR_P (decl)
2234
      && !DECL_CONV_FN_P (decl))
2235
    {
2236
      java_method_p = 1;
2237
      write_char ('J');
2238
    }
2239
  else
2240
    {
2241
      java_method_p = 0;
2242
    }
2243
 
2244
  /* Mangle the return type, if requested.  */
2245
  if (include_return_type_p || java_method_p)
2246
    write_type (TREE_TYPE (type));
2247
 
2248
  /* Now mangle the types of the arguments.  */
2249
  write_method_parms (TYPE_ARG_TYPES (type),
2250
                      TREE_CODE (type) == METHOD_TYPE,
2251
                      decl);
2252
}
2253
 
2254
/* Write the mangled representation of a method parameter list of
2255
   types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2256
   considered a non-static method, and the this parameter is omitted.
2257
   If non-NULL, DECL is the FUNCTION_DECL for the function whose
2258
   parameters are being emitted.  */
2259
 
2260
static void
2261
write_method_parms (tree parm_types, const int method_p, const tree decl)
2262
{
2263
  tree first_parm_type;
2264
  tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2265
 
2266
  /* Assume this parameter type list is variable-length.  If it ends
2267
     with a void type, then it's not.  */
2268
  int varargs_p = 1;
2269
 
2270
  /* If this is a member function, skip the first arg, which is the
2271
     this pointer.
2272
       "Member functions do not encode the type of their implicit this
2273
       parameter."
2274
 
2275
     Similarly, there's no need to mangle artificial parameters, like
2276
     the VTT parameters for constructors and destructors.  */
2277
  if (method_p)
2278
    {
2279
      parm_types = TREE_CHAIN (parm_types);
2280
      parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
2281
 
2282
      while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2283
        {
2284
          parm_types = TREE_CHAIN (parm_types);
2285
          parm_decl = TREE_CHAIN (parm_decl);
2286
        }
2287
    }
2288
 
2289
  for (first_parm_type = parm_types;
2290
       parm_types;
2291
       parm_types = TREE_CHAIN (parm_types))
2292
    {
2293
      tree parm = TREE_VALUE (parm_types);
2294
      if (parm == void_type_node)
2295
        {
2296
          /* "Empty parameter lists, whether declared as () or
2297
             conventionally as (void), are encoded with a void parameter
2298
             (v)."  */
2299
          if (parm_types == first_parm_type)
2300
            write_type (parm);
2301
          /* If the parm list is terminated with a void type, it's
2302
             fixed-length.  */
2303
          varargs_p = 0;
2304
          /* A void type better be the last one.  */
2305
          gcc_assert (TREE_CHAIN (parm_types) == NULL);
2306
        }
2307
      else
2308
        write_type (parm);
2309
    }
2310
 
2311
  if (varargs_p)
2312
    /* <builtin-type> ::= z  # ellipsis  */
2313
    write_char ('z');
2314
}
2315
 
2316
/* <class-enum-type> ::= <name>  */
2317
 
2318
static void
2319
write_class_enum_type (const tree type)
2320
{
2321
  write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2322
}
2323
 
2324
/* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2325
   arguments.
2326
 
2327
     <template-args> ::= I <template-arg>* E  */
2328
 
2329
static void
2330
write_template_args (tree args)
2331
{
2332
  int i;
2333
  int length = 0;
2334
 
2335
  MANGLE_TRACE_TREE ("template-args", args);
2336
 
2337
  write_char ('I');
2338
 
2339
  if (args)
2340
    length = TREE_VEC_LENGTH (args);
2341
 
2342
  if (args && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2343
    {
2344
      /* We have nested template args.  We want the innermost template
2345
         argument list.  */
2346
      args = TREE_VEC_ELT (args, length - 1);
2347
      length = TREE_VEC_LENGTH (args);
2348
    }
2349
  for (i = 0; i < length; ++i)
2350
    write_template_arg (TREE_VEC_ELT (args, i));
2351
 
2352
  write_char ('E');
2353
}
2354
 
2355
/* Write out the
2356
   <unqualified-name>
2357
   <unqualified-name> <template-args>
2358
   part of SCOPE_REF or COMPONENT_REF mangling.  */
2359
 
2360
static void
2361
write_member_name (tree member)
2362
{
2363
  if (TREE_CODE (member) == IDENTIFIER_NODE)
2364
    write_unqualified_id (member);
2365
  else if (DECL_P (member))
2366
    write_unqualified_name (member);
2367
  else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2368
    {
2369
      tree name = TREE_OPERAND (member, 0);
2370
      if (TREE_CODE (name) == OVERLOAD)
2371
        name = OVL_FUNCTION (name);
2372
      write_member_name (name);
2373
      write_template_args (TREE_OPERAND (member, 1));
2374
    }
2375
  else
2376
    write_expression (member);
2377
}
2378
 
2379
/* <expression> ::= <unary operator-name> <expression>
2380
                ::= <binary operator-name> <expression> <expression>
2381
                ::= <expr-primary>
2382
 
2383
   <expr-primary> ::= <template-param>
2384
                  ::= L <type> <value number> E         # literal
2385
                  ::= L <mangled-name> E                # external name
2386
                  ::= st <type>                         # sizeof
2387
                  ::= sr <type> <unqualified-name>      # dependent name
2388
                  ::= sr <type> <unqualified-name> <template-args> */
2389
 
2390
static void
2391
write_expression (tree expr)
2392
{
2393
  enum tree_code code = TREE_CODE (expr);
2394
 
2395
  /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
2396
     is converted (via qualification conversions) to another
2397
     type.  */
2398
  while (TREE_CODE (expr) == NOP_EXPR
2399
         || TREE_CODE (expr) == NON_LVALUE_EXPR)
2400
    {
2401
      expr = TREE_OPERAND (expr, 0);
2402
      code = TREE_CODE (expr);
2403
    }
2404
 
2405
  if (code == BASELINK)
2406
    {
2407
      expr = BASELINK_FUNCTIONS (expr);
2408
      code = TREE_CODE (expr);
2409
    }
2410
 
2411
  /* Handle pointers-to-members by making them look like expression
2412
     nodes.  */
2413
  if (code == PTRMEM_CST)
2414
    {
2415
      expr = build_nt (ADDR_EXPR,
2416
                       build_qualified_name (/*type=*/NULL_TREE,
2417
                                             PTRMEM_CST_CLASS (expr),
2418
                                             PTRMEM_CST_MEMBER (expr),
2419
                                             /*template_p=*/false));
2420
      code = TREE_CODE (expr);
2421
    }
2422
 
2423
  /* Handle template parameters.  */
2424
  if (code == TEMPLATE_TYPE_PARM
2425
      || code == TEMPLATE_TEMPLATE_PARM
2426
      || code == BOUND_TEMPLATE_TEMPLATE_PARM
2427
      || code == TEMPLATE_PARM_INDEX)
2428
    write_template_param (expr);
2429
  /* Handle literals.  */
2430
  else if (TREE_CODE_CLASS (code) == tcc_constant
2431
           || (abi_version_at_least (2) && code == CONST_DECL))
2432
    write_template_arg_literal (expr);
2433
  else if (code == PARM_DECL)
2434
    {
2435
      /* A function parameter used in a late-specified return type.  */
2436
      int index = DECL_PARM_INDEX (expr);
2437
      gcc_assert (index >= 1);
2438
      write_string ("fp");
2439
      write_compact_number (index - 1);
2440
    }
2441
  else if (DECL_P (expr))
2442
    {
2443
      /* G++ 3.2 incorrectly mangled non-type template arguments of
2444
         enumeration type using their names.  */
2445
      if (code == CONST_DECL)
2446
        G.need_abi_warning = 1;
2447
      write_char ('L');
2448
      write_mangled_name (expr, false);
2449
      write_char ('E');
2450
    }
2451
  else if (TREE_CODE (expr) == SIZEOF_EXPR
2452
           && TYPE_P (TREE_OPERAND (expr, 0)))
2453
    {
2454
      write_string ("st");
2455
      write_type (TREE_OPERAND (expr, 0));
2456
    }
2457
  else if (TREE_CODE (expr) == ALIGNOF_EXPR
2458
           && TYPE_P (TREE_OPERAND (expr, 0)))
2459
    {
2460
      write_string ("at");
2461
      write_type (TREE_OPERAND (expr, 0));
2462
    }
2463
  else if (TREE_CODE (expr) == SCOPE_REF)
2464
    {
2465
      tree scope = TREE_OPERAND (expr, 0);
2466
      tree member = TREE_OPERAND (expr, 1);
2467
 
2468
      if (!abi_version_at_least (2))
2469
        {
2470
          write_string ("sr");
2471
          write_type (scope);
2472
          /* G++ 3.2 incorrectly put out both the "sr" code and
2473
             the nested name of the qualified name.  */
2474
          G.need_abi_warning = 1;
2475
          write_encoding (member);
2476
        }
2477
 
2478
      /* If the MEMBER is a real declaration, then the qualifying
2479
         scope was not dependent.  Ideally, we would not have a
2480
         SCOPE_REF in those cases, but sometimes we do.  If the second
2481
         argument is a DECL, then the name must not have been
2482
         dependent.  */
2483
      else if (DECL_P (member))
2484
        write_expression (member);
2485
      else
2486
        {
2487
          write_string ("sr");
2488
          write_type (scope);
2489
          write_member_name (member);
2490
        }
2491
    }
2492
  else if (TREE_CODE (expr) == INDIRECT_REF
2493
           && TREE_TYPE (TREE_OPERAND (expr, 0))
2494
           && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2495
    {
2496
      write_expression (TREE_OPERAND (expr, 0));
2497
    }
2498
  else if (TREE_CODE (expr) == IDENTIFIER_NODE)
2499
    {
2500
      /* An operator name appearing as a dependent name needs to be
2501
         specially marked to disambiguate between a use of the operator
2502
         name and a use of the operator in an expression.  */
2503
      if (IDENTIFIER_OPNAME_P (expr))
2504
        write_string ("on");
2505
      write_unqualified_id (expr);
2506
    }
2507
  else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
2508
    {
2509
      tree fn = TREE_OPERAND (expr, 0);
2510
      if (is_overloaded_fn (fn))
2511
        fn = DECL_NAME (get_first_fn (fn));
2512
      if (IDENTIFIER_OPNAME_P (fn))
2513
        write_string ("on");
2514
      write_unqualified_id (fn);
2515
      write_template_args (TREE_OPERAND (expr, 1));
2516
    }
2517
  else
2518
    {
2519
      int i, len;
2520
      const char *name;
2521
 
2522
      /* When we bind a variable or function to a non-type template
2523
         argument with reference type, we create an ADDR_EXPR to show
2524
         the fact that the entity's address has been taken.  But, we
2525
         don't actually want to output a mangling code for the `&'.  */
2526
      if (TREE_CODE (expr) == ADDR_EXPR
2527
          && TREE_TYPE (expr)
2528
          && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2529
        {
2530
          expr = TREE_OPERAND (expr, 0);
2531
          if (DECL_P (expr))
2532
            {
2533
              write_expression (expr);
2534
              return;
2535
            }
2536
 
2537
          code = TREE_CODE (expr);
2538
        }
2539
 
2540
      if (code == COMPONENT_REF)
2541
        {
2542
          tree ob = TREE_OPERAND (expr, 0);
2543
 
2544
          if (TREE_CODE (ob) == ARROW_EXPR)
2545
            {
2546
              write_string (operator_name_info[(int)code].mangled_name);
2547
              ob = TREE_OPERAND (ob, 0);
2548
            }
2549
          else
2550
            write_string ("dt");
2551
 
2552
          write_expression (ob);
2553
          write_member_name (TREE_OPERAND (expr, 1));
2554
          return;
2555
        }
2556
 
2557
      /* If it wasn't any of those, recursively expand the expression.  */
2558
      name = operator_name_info[(int) code].mangled_name;
2559
      if (name == NULL)
2560
        {
2561
          sorry ("mangling %C", code);
2562
          return;
2563
        }
2564
      else
2565
        write_string (name);
2566
 
2567
      switch (code)
2568
        {
2569
        case CALL_EXPR:
2570
          {
2571
            tree fn = CALL_EXPR_FN (expr);
2572
 
2573
            if (TREE_CODE (fn) == ADDR_EXPR)
2574
              fn = TREE_OPERAND (fn, 0);
2575
 
2576
            /* Mangle a dependent name as the name, not whatever happens to
2577
               be the first function in the overload set.  */
2578
            if ((TREE_CODE (fn) == FUNCTION_DECL
2579
                 || TREE_CODE (fn) == OVERLOAD)
2580
                && type_dependent_expression_p_push (expr))
2581
              fn = DECL_NAME (get_first_fn (fn));
2582
 
2583
            write_expression (fn);
2584
          }
2585
 
2586
          for (i = 0; i < call_expr_nargs (expr); ++i)
2587
            write_expression (CALL_EXPR_ARG (expr, i));
2588
          write_char ('E');
2589
          break;
2590
 
2591
        case CAST_EXPR:
2592
          write_type (TREE_TYPE (expr));
2593
          if (list_length (TREE_OPERAND (expr, 0)) == 1)
2594
            write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2595
          else
2596
            {
2597
              tree args = TREE_OPERAND (expr, 0);
2598
              write_char ('_');
2599
              for (; args; args = TREE_CHAIN (args))
2600
                write_expression (TREE_VALUE (args));
2601
              write_char ('E');
2602
            }
2603
          break;
2604
 
2605
          /* FIXME these should have a distinct mangling.  */
2606
        case STATIC_CAST_EXPR:
2607
        case CONST_CAST_EXPR:
2608
          write_type (TREE_TYPE (expr));
2609
          write_expression (TREE_OPERAND (expr, 0));
2610
          break;
2611
 
2612
        case NEW_EXPR:
2613
          sorry ("mangling new-expression");
2614
          break;
2615
 
2616
        default:
2617
          /* In the middle-end, some expressions have more operands than
2618
             they do in templates (and mangling).  */
2619
          switch (code)
2620
            {
2621
            case PREINCREMENT_EXPR:
2622
            case PREDECREMENT_EXPR:
2623
            case POSTINCREMENT_EXPR:
2624
            case POSTDECREMENT_EXPR:
2625
              len = 1;
2626
              break;
2627
 
2628
            case ARRAY_REF:
2629
              len = 2;
2630
              break;
2631
 
2632
            default:
2633
              len = TREE_OPERAND_LENGTH (expr);
2634
              break;
2635
            }
2636
 
2637
          for (i = 0; i < len; ++i)
2638
            {
2639
              tree operand = TREE_OPERAND (expr, i);
2640
              /* As a GNU extension, the middle operand of a
2641
                 conditional may be omitted.  Since expression
2642
                 manglings are supposed to represent the input token
2643
                 stream, there's no good way to mangle such an
2644
                 expression without extending the C++ ABI.  */
2645
              if (code == COND_EXPR && i == 1 && !operand)
2646
                {
2647
                  error ("omitted middle operand to %<?:%> operand "
2648
                         "cannot be mangled");
2649
                  continue;
2650
                }
2651
              write_expression (operand);
2652
            }
2653
        }
2654
    }
2655
}
2656
 
2657
/* Literal subcase of non-terminal <template-arg>.
2658
 
2659
     "Literal arguments, e.g. "A<42L>", are encoded with their type
2660
     and value. Negative integer values are preceded with "n"; for
2661
     example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2662
     encoded as 0, true as 1."  */
2663
 
2664
static void
2665
write_template_arg_literal (const tree value)
2666
{
2667
  write_char ('L');
2668
  write_type (TREE_TYPE (value));
2669
 
2670
  switch (TREE_CODE (value))
2671
    {
2672
    case CONST_DECL:
2673
      write_integer_cst (DECL_INITIAL (value));
2674
      break;
2675
 
2676
    case INTEGER_CST:
2677
      gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2678
                  || integer_zerop (value) || integer_onep (value));
2679
      write_integer_cst (value);
2680
      break;
2681
 
2682
    case REAL_CST:
2683
      write_real_cst (value);
2684
      break;
2685
 
2686
    default:
2687
      gcc_unreachable ();
2688
    }
2689
 
2690
  write_char ('E');
2691
}
2692
 
2693
/* Non-terminal <template-arg>.
2694
 
2695
     <template-arg> ::= <type>                          # type
2696
                    ::= L <type> </value/ number> E     # literal
2697
                    ::= LZ <name> E                     # external name
2698
                    ::= X <expression> E                # expression  */
2699
 
2700
static void
2701
write_template_arg (tree node)
2702
{
2703
  enum tree_code code = TREE_CODE (node);
2704
 
2705
  MANGLE_TRACE_TREE ("template-arg", node);
2706
 
2707
  /* A template template parameter's argument list contains TREE_LIST
2708
     nodes of which the value field is the actual argument.  */
2709
  if (code == TREE_LIST)
2710
    {
2711
      node = TREE_VALUE (node);
2712
      /* If it's a decl, deal with its type instead.  */
2713
      if (DECL_P (node))
2714
        {
2715
          node = TREE_TYPE (node);
2716
          code = TREE_CODE (node);
2717
        }
2718
    }
2719
 
2720
  if (TREE_CODE (node) == NOP_EXPR
2721
      && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2722
    {
2723
      /* Template parameters can be of reference type. To maintain
2724
         internal consistency, such arguments use a conversion from
2725
         address of object to reference type.  */
2726
      gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2727
      if (abi_version_at_least (2))
2728
        node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2729
      else
2730
        G.need_abi_warning = 1;
2731
    }
2732
 
2733
  if (ARGUMENT_PACK_P (node))
2734
    {
2735
      /* Expand the template argument pack. */
2736
      tree args = ARGUMENT_PACK_ARGS (node);
2737
      int i, length = TREE_VEC_LENGTH (args);
2738
      write_char ('I');
2739
      for (i = 0; i < length; ++i)
2740
        write_template_arg (TREE_VEC_ELT (args, i));
2741
      write_char ('E');
2742
    }
2743
  else if (TYPE_P (node))
2744
    write_type (node);
2745
  else if (code == TEMPLATE_DECL)
2746
    /* A template appearing as a template arg is a template template arg.  */
2747
    write_template_template_arg (node);
2748
  else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2749
           || (abi_version_at_least (2) && code == CONST_DECL))
2750
    write_template_arg_literal (node);
2751
  else if (DECL_P (node))
2752
    {
2753
      /* Until ABI version 2, non-type template arguments of
2754
         enumeration type were mangled using their names.  */
2755
      if (code == CONST_DECL && !abi_version_at_least (2))
2756
        G.need_abi_warning = 1;
2757
      write_char ('L');
2758
      /* Until ABI version 3, the underscore before the mangled name
2759
         was incorrectly omitted.  */
2760
      if (!abi_version_at_least (3))
2761
        {
2762
          G.need_abi_warning = 1;
2763
          write_char ('Z');
2764
        }
2765
      else
2766
        write_string ("_Z");
2767
      write_encoding (node);
2768
      write_char ('E');
2769
    }
2770
  else
2771
    {
2772
      /* Template arguments may be expressions.  */
2773
      write_char ('X');
2774
      write_expression (node);
2775
      write_char ('E');
2776
    }
2777
}
2778
 
2779
/*  <template-template-arg>
2780
                        ::= <name>
2781
                        ::= <substitution>  */
2782
 
2783
static void
2784
write_template_template_arg (const tree decl)
2785
{
2786
  MANGLE_TRACE_TREE ("template-template-arg", decl);
2787
 
2788
  if (find_substitution (decl))
2789
    return;
2790
  write_name (decl, /*ignore_local_scope=*/0);
2791
  add_substitution (decl);
2792
}
2793
 
2794
 
2795
/* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2796
 
2797
     <array-type> ::= A [</dimension/ number>] _ </element/ type>
2798
                  ::= A <expression> _ </element/ type>
2799
 
2800
     "Array types encode the dimension (number of elements) and the
2801
     element type. For variable length arrays, the dimension (but not
2802
     the '_' separator) is omitted."  */
2803
 
2804
static void
2805
write_array_type (const tree type)
2806
{
2807
  write_char ('A');
2808
  if (TYPE_DOMAIN (type))
2809
    {
2810
      tree index_type;
2811
      tree max;
2812
 
2813
      index_type = TYPE_DOMAIN (type);
2814
      /* The INDEX_TYPE gives the upper and lower bounds of the
2815
         array.  */
2816
      max = TYPE_MAX_VALUE (index_type);
2817
      if (TREE_CODE (max) == INTEGER_CST)
2818
        {
2819
          /* The ABI specifies that we should mangle the number of
2820
             elements in the array, not the largest allowed index.  */
2821
          max = size_binop (PLUS_EXPR, max, size_one_node);
2822
          write_unsigned_number (tree_low_cst (max, 1));
2823
        }
2824
      else
2825
        {
2826
          max = TREE_OPERAND (max, 0);
2827
          if (!abi_version_at_least (2))
2828
            {
2829
              /* value_dependent_expression_p presumes nothing is
2830
                 dependent when PROCESSING_TEMPLATE_DECL is zero.  */
2831
              ++processing_template_decl;
2832
              if (!value_dependent_expression_p (max))
2833
                G.need_abi_warning = 1;
2834
              --processing_template_decl;
2835
            }
2836
          write_expression (max);
2837
        }
2838
 
2839
    }
2840
  write_char ('_');
2841
  write_type (TREE_TYPE (type));
2842
}
2843
 
2844
/* Non-terminal <pointer-to-member-type> for pointer-to-member
2845
   variables.  TYPE is a pointer-to-member POINTER_TYPE.
2846
 
2847
     <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2848
 
2849
static void
2850
write_pointer_to_member_type (const tree type)
2851
{
2852
  write_char ('M');
2853
  write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2854
  write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2855
}
2856
 
2857
/* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2858
   TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2859
   TEMPLATE_PARM_INDEX.
2860
 
2861
     <template-param> ::= T </parameter/ number> _  */
2862
 
2863
static void
2864
write_template_param (const tree parm)
2865
{
2866
  int parm_index;
2867
 
2868
  MANGLE_TRACE_TREE ("template-parm", parm);
2869
 
2870
  switch (TREE_CODE (parm))
2871
    {
2872
    case TEMPLATE_TYPE_PARM:
2873
    case TEMPLATE_TEMPLATE_PARM:
2874
    case BOUND_TEMPLATE_TEMPLATE_PARM:
2875
      parm_index = TEMPLATE_TYPE_IDX (parm);
2876
      break;
2877
 
2878
    case TEMPLATE_PARM_INDEX:
2879
      parm_index = TEMPLATE_PARM_IDX (parm);
2880
      break;
2881
 
2882
    default:
2883
      gcc_unreachable ();
2884
    }
2885
 
2886
  write_char ('T');
2887
  /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2888
     earliest template param denoted by `_'.  */
2889
  write_compact_number (parm_index);
2890
}
2891
 
2892
/*  <template-template-param>
2893
                        ::= <template-param>
2894
                        ::= <substitution>  */
2895
 
2896
static void
2897
write_template_template_param (const tree parm)
2898
{
2899
  tree templ = NULL_TREE;
2900
 
2901
  /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2902
     template template parameter.  The substitution candidate here is
2903
     only the template.  */
2904
  if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2905
    {
2906
      templ
2907
        = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2908
      if (find_substitution (templ))
2909
        return;
2910
    }
2911
 
2912
  /* <template-param> encodes only the template parameter position,
2913
     not its template arguments, which is fine here.  */
2914
  write_template_param (parm);
2915
  if (templ)
2916
    add_substitution (templ);
2917
}
2918
 
2919
/* Non-terminal <substitution>.
2920
 
2921
      <substitution> ::= S <seq-id> _
2922
                     ::= S_  */
2923
 
2924
static void
2925
write_substitution (const int seq_id)
2926
{
2927
  MANGLE_TRACE ("substitution", "");
2928
 
2929
  write_char ('S');
2930
  if (seq_id > 0)
2931
    write_number (seq_id - 1, /*unsigned=*/1, 36);
2932
  write_char ('_');
2933
}
2934
 
2935
/* Start mangling ENTITY.  */
2936
 
2937
static inline void
2938
start_mangling (const tree entity)
2939
{
2940
  G.entity = entity;
2941
  G.need_abi_warning = false;
2942
  obstack_free (&name_obstack, name_base);
2943
  mangle_obstack = &name_obstack;
2944
  name_base = obstack_alloc (&name_obstack, 0);
2945
}
2946
 
2947
/* Done with mangling. If WARN is true, and the name of G.entity will
2948
   be mangled differently in a future version of the ABI, issue a
2949
   warning.  */
2950
 
2951
static void
2952
finish_mangling_internal (const bool warn)
2953
{
2954
  if (warn_abi && warn && G.need_abi_warning)
2955
    warning (OPT_Wabi, "the mangled name of %qD will change in a future "
2956
             "version of GCC",
2957
             G.entity);
2958
 
2959
  /* Clear all the substitutions.  */
2960
  VEC_truncate (tree, G.substitutions, 0);
2961
 
2962
  /* Null-terminate the string.  */
2963
  write_char ('\0');
2964
}
2965
 
2966
 
2967
/* Like finish_mangling_internal, but return the mangled string.  */
2968
 
2969
static inline const char *
2970
finish_mangling (const bool warn)
2971
{
2972
  finish_mangling_internal (warn);
2973
  return (const char *) obstack_finish (mangle_obstack);
2974
}
2975
 
2976
/* Like finish_mangling_internal, but return an identifier.  */
2977
 
2978
static tree
2979
finish_mangling_get_identifier (const bool warn)
2980
{
2981
  finish_mangling_internal (warn);
2982
  /* Don't obstack_finish here, and the next start_mangling will
2983
     remove the identifier.  */
2984
  return get_identifier ((const char *) obstack_base (mangle_obstack));
2985
}
2986
 
2987
/* Initialize data structures for mangling.  */
2988
 
2989
void
2990
init_mangle (void)
2991
{
2992
  gcc_obstack_init (&name_obstack);
2993
  name_base = obstack_alloc (&name_obstack, 0);
2994
  G.substitutions = NULL;
2995
 
2996
  /* Cache these identifiers for quick comparison when checking for
2997
     standard substitutions.  */
2998
  subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2999
  subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3000
  subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3001
  subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3002
  subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3003
  subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3004
}
3005
 
3006
/* Generate the mangled name of DECL.  */
3007
 
3008
static tree
3009
mangle_decl_string (const tree decl)
3010
{
3011
  tree result;
3012
  location_t saved_loc = input_location;
3013
  tree saved_fn = NULL_TREE;
3014
  bool template_p = false;
3015
 
3016
  if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3017
    {
3018
      struct tinst_level *tl = current_instantiation ();
3019
      if (!tl || tl->decl != decl)
3020
        {
3021
          template_p = true;
3022
          saved_fn = current_function_decl;
3023
          push_tinst_level (decl);
3024
          current_function_decl = NULL_TREE;
3025
        }
3026
    }
3027
  input_location = DECL_SOURCE_LOCATION (decl);
3028
 
3029
  start_mangling (decl);
3030
 
3031
  if (TREE_CODE (decl) == TYPE_DECL)
3032
    write_type (TREE_TYPE (decl));
3033
  else
3034
    write_mangled_name (decl, true);
3035
 
3036
  result = finish_mangling_get_identifier (/*warn=*/true);
3037
  if (DEBUG_MANGLE)
3038
    fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3039
             IDENTIFIER_POINTER (result));
3040
 
3041
  if (template_p)
3042
    {
3043
      pop_tinst_level ();
3044
      current_function_decl = saved_fn;
3045
    }
3046
  input_location = saved_loc;
3047
 
3048
  return result;
3049
}
3050
 
3051
/* Create an identifier for the external mangled name of DECL.  */
3052
 
3053
void
3054
mangle_decl (const tree decl)
3055
{
3056
  tree id = mangle_decl_string (decl);
3057
  id = targetm.mangle_decl_assembler_name (decl, id);
3058
  SET_DECL_ASSEMBLER_NAME (decl, id);
3059
 
3060
  if (G.need_abi_warning)
3061
    {
3062
#ifdef ASM_OUTPUT_DEF
3063
      /* If the mangling will change in the future, emit an alias with the
3064
         future mangled name for forward-compatibility.  */
3065
      int save_ver;
3066
      tree id2, alias;
3067
#endif
3068
 
3069
      SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3070
      if (IDENTIFIER_GLOBAL_VALUE (id) != decl)
3071
        inform (DECL_SOURCE_LOCATION (decl), "-fabi-version=4 (or =0) "
3072
                "avoids this error with a change in vector mangling");
3073
 
3074
#ifdef ASM_OUTPUT_DEF
3075
      save_ver = flag_abi_version;
3076
      flag_abi_version = 0;
3077
      id2 = mangle_decl_string (decl);
3078
      id2 = targetm.mangle_decl_assembler_name (decl, id2);
3079
      flag_abi_version = save_ver;
3080
 
3081
      alias = make_alias_for (decl, id2);
3082
      DECL_IGNORED_P (alias) = 1;
3083
      TREE_PUBLIC (alias) = TREE_PUBLIC (decl);
3084
      DECL_VISIBILITY (alias) = DECL_VISIBILITY (decl);
3085
      if (vague_linkage_p (decl))
3086
        DECL_WEAK (alias) = 1;
3087
      if (TREE_CODE (decl) == FUNCTION_DECL)
3088
        cgraph_same_body_alias (alias, decl);
3089
      else
3090
        varpool_extra_name_alias (alias, decl);
3091
#endif
3092
    }
3093
}
3094
 
3095
/* Generate the mangled representation of TYPE.  */
3096
 
3097
const char *
3098
mangle_type_string (const tree type)
3099
{
3100
  const char *result;
3101
 
3102
  start_mangling (type);
3103
  write_type (type);
3104
  result = finish_mangling (/*warn=*/false);
3105
  if (DEBUG_MANGLE)
3106
    fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3107
  return result;
3108
}
3109
 
3110
/* Create an identifier for the mangled name of a special component
3111
   for belonging to TYPE.  CODE is the ABI-specified code for this
3112
   component.  */
3113
 
3114
static tree
3115
mangle_special_for_type (const tree type, const char *code)
3116
{
3117
  tree result;
3118
 
3119
  /* We don't have an actual decl here for the special component, so
3120
     we can't just process the <encoded-name>.  Instead, fake it.  */
3121
  start_mangling (type);
3122
 
3123
  /* Start the mangling.  */
3124
  write_string ("_Z");
3125
  write_string (code);
3126
 
3127
  /* Add the type.  */
3128
  write_type (type);
3129
  result = finish_mangling_get_identifier (/*warn=*/false);
3130
 
3131
  if (DEBUG_MANGLE)
3132
    fprintf (stderr, "mangle_special_for_type = %s\n\n",
3133
             IDENTIFIER_POINTER (result));
3134
 
3135
  return result;
3136
}
3137
 
3138
/* Create an identifier for the mangled representation of the typeinfo
3139
   structure for TYPE.  */
3140
 
3141
tree
3142
mangle_typeinfo_for_type (const tree type)
3143
{
3144
  return mangle_special_for_type (type, "TI");
3145
}
3146
 
3147
/* Create an identifier for the mangled name of the NTBS containing
3148
   the mangled name of TYPE.  */
3149
 
3150
tree
3151
mangle_typeinfo_string_for_type (const tree type)
3152
{
3153
  return mangle_special_for_type (type, "TS");
3154
}
3155
 
3156
/* Create an identifier for the mangled name of the vtable for TYPE.  */
3157
 
3158
tree
3159
mangle_vtbl_for_type (const tree type)
3160
{
3161
  return mangle_special_for_type (type, "TV");
3162
}
3163
 
3164
/* Returns an identifier for the mangled name of the VTT for TYPE.  */
3165
 
3166
tree
3167
mangle_vtt_for_type (const tree type)
3168
{
3169
  return mangle_special_for_type (type, "TT");
3170
}
3171
 
3172
/* Return an identifier for a construction vtable group.  TYPE is
3173
   the most derived class in the hierarchy; BINFO is the base
3174
   subobject for which this construction vtable group will be used.
3175
 
3176
   This mangling isn't part of the ABI specification; in the ABI
3177
   specification, the vtable group is dumped in the same COMDAT as the
3178
   main vtable, and is referenced only from that vtable, so it doesn't
3179
   need an external name.  For binary formats without COMDAT sections,
3180
   though, we need external names for the vtable groups.
3181
 
3182
   We use the production
3183
 
3184
    <special-name> ::= CT <type> <offset number> _ <base type>  */
3185
 
3186
tree
3187
mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
3188
{
3189
  tree result;
3190
 
3191
  start_mangling (type);
3192
 
3193
  write_string ("_Z");
3194
  write_string ("TC");
3195
  write_type (type);
3196
  write_integer_cst (BINFO_OFFSET (binfo));
3197
  write_char ('_');
3198
  write_type (BINFO_TYPE (binfo));
3199
 
3200
  result = finish_mangling_get_identifier (/*warn=*/false);
3201
  if (DEBUG_MANGLE)
3202
    fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
3203
             IDENTIFIER_POINTER (result));
3204
  return result;
3205
}
3206
 
3207
/* Mangle a this pointer or result pointer adjustment.
3208
 
3209
   <call-offset> ::= h <fixed offset number> _
3210
                 ::= v <fixed offset number> _ <virtual offset number> _ */
3211
 
3212
static void
3213
mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
3214
{
3215
  write_char (virtual_offset ? 'v' : 'h');
3216
 
3217
  /* For either flavor, write the fixed offset.  */
3218
  write_integer_cst (fixed_offset);
3219
  write_char ('_');
3220
 
3221
  /* For a virtual thunk, add the virtual offset.  */
3222
  if (virtual_offset)
3223
    {
3224
      write_integer_cst (virtual_offset);
3225
      write_char ('_');
3226
    }
3227
}
3228
 
3229
/* Return an identifier for the mangled name of a this-adjusting or
3230
   covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
3231
   to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
3232
   is a virtual thunk, and it is the vtbl offset in
3233
   bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3234
   zero for a covariant thunk. Note, that FN_DECL might be a covariant
3235
   thunk itself. A covariant thunk name always includes the adjustment
3236
   for the this pointer, even if there is none.
3237
 
3238
   <special-name> ::= T <call-offset> <base encoding>
3239
                  ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3240
                                        <base encoding>  */
3241
 
3242
tree
3243
mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
3244
              tree virtual_offset)
3245
{
3246
  tree result;
3247
 
3248
  start_mangling (fn_decl);
3249
 
3250
  write_string ("_Z");
3251
  write_char ('T');
3252
 
3253
  if (!this_adjusting)
3254
    {
3255
      /* Covariant thunk with no this adjustment */
3256
      write_char ('c');
3257
      mangle_call_offset (integer_zero_node, NULL_TREE);
3258
      mangle_call_offset (fixed_offset, virtual_offset);
3259
    }
3260
  else if (!DECL_THUNK_P (fn_decl))
3261
    /* Plain this adjusting thunk.  */
3262
    mangle_call_offset (fixed_offset, virtual_offset);
3263
  else
3264
    {
3265
      /* This adjusting thunk to covariant thunk.  */
3266
      write_char ('c');
3267
      mangle_call_offset (fixed_offset, virtual_offset);
3268
      fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
3269
      virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
3270
      if (virtual_offset)
3271
        virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
3272
      mangle_call_offset (fixed_offset, virtual_offset);
3273
      fn_decl = THUNK_TARGET (fn_decl);
3274
    }
3275
 
3276
  /* Scoped name.  */
3277
  write_encoding (fn_decl);
3278
 
3279
  result = finish_mangling_get_identifier (/*warn=*/false);
3280
  if (DEBUG_MANGLE)
3281
    fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
3282
  return result;
3283
}
3284
 
3285
/* This hash table maps TYPEs to the IDENTIFIER for a conversion
3286
   operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
3287
   TYPE.  */
3288
 
3289
static GTY ((param_is (union tree_node))) htab_t conv_type_names;
3290
 
3291
/* Hash a node (VAL1) in the table.  */
3292
 
3293
static hashval_t
3294
hash_type (const void *val)
3295
{
3296
  return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3297
}
3298
 
3299
/* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
3300
 
3301
static int
3302
compare_type (const void *val1, const void *val2)
3303
{
3304
  return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3305
}
3306
 
3307
/* Return an identifier for the mangled unqualified name for a
3308
   conversion operator to TYPE.  This mangling is not specified by the
3309
   ABI spec; it is only used internally.  */
3310
 
3311
tree
3312
mangle_conv_op_name_for_type (const tree type)
3313
{
3314
  void **slot;
3315
  tree identifier;
3316
 
3317
  if (type == error_mark_node)
3318
    return error_mark_node;
3319
 
3320
  if (conv_type_names == NULL)
3321
    conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3322
 
3323
  slot = htab_find_slot_with_hash (conv_type_names, type,
3324
                                   (hashval_t) TYPE_UID (type), INSERT);
3325
  identifier = (tree)*slot;
3326
  if (!identifier)
3327
    {
3328
      char buffer[64];
3329
 
3330
       /* Create a unique name corresponding to TYPE.  */
3331
      sprintf (buffer, "operator %lu",
3332
               (unsigned long) htab_elements (conv_type_names));
3333
      identifier = get_identifier (buffer);
3334
      *slot = identifier;
3335
 
3336
      /* Hang TYPE off the identifier so it can be found easily later
3337
         when performing conversions.  */
3338
      TREE_TYPE (identifier) = type;
3339
 
3340
      /* Set bits on the identifier so we know later it's a conversion.  */
3341
      IDENTIFIER_OPNAME_P (identifier) = 1;
3342
      IDENTIFIER_TYPENAME_P (identifier) = 1;
3343
    }
3344
 
3345
  return identifier;
3346
}
3347
 
3348
/* Return an identifier for the name of an initialization guard
3349
   variable for indicated VARIABLE.  */
3350
 
3351
tree
3352
mangle_guard_variable (const tree variable)
3353
{
3354
  start_mangling (variable);
3355
  write_string ("_ZGV");
3356
  if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3357
    /* The name of a guard variable for a reference temporary should refer
3358
       to the reference, not the temporary.  */
3359
    write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3360
  else
3361
    write_name (variable, /*ignore_local_scope=*/0);
3362
  return finish_mangling_get_identifier (/*warn=*/false);
3363
}
3364
 
3365
/* Return an identifier for the name of a temporary variable used to
3366
   initialize a static reference.  This isn't part of the ABI, but we might
3367
   as well call them something readable.  */
3368
 
3369
tree
3370
mangle_ref_init_variable (const tree variable)
3371
{
3372
  start_mangling (variable);
3373
  write_string ("_ZGR");
3374
  write_name (variable, /*ignore_local_scope=*/0);
3375
  return finish_mangling_get_identifier (/*warn=*/false);
3376
}
3377
 
3378
 
3379
/* Foreign language type mangling section.  */
3380
 
3381
/* How to write the type codes for the integer Java type.  */
3382
 
3383
static void
3384
write_java_integer_type_codes (const tree type)
3385
{
3386
  if (type == java_int_type_node)
3387
    write_char ('i');
3388
  else if (type == java_short_type_node)
3389
    write_char ('s');
3390
  else if (type == java_byte_type_node)
3391
    write_char ('c');
3392
  else if (type == java_char_type_node)
3393
    write_char ('w');
3394
  else if (type == java_long_type_node)
3395
    write_char ('x');
3396
  else if (type == java_boolean_type_node)
3397
    write_char ('b');
3398
  else
3399
    gcc_unreachable ();
3400
}
3401
 
3402
#include "gt-cp-mangle.h"

powered by: WebSVN 2.1.0

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