Patchwork demangle C++ extern "C" functions

login
register
mail settings
Submitter Marc Glisse
Date Sept. 3, 2011, 9:05 p.m.
Message ID <alpine.DEB.2.02.1109032229590.6207@laptop-mg.saclay.inria.fr>
Download mbox | patch
Permalink /patch/113256/
State New
Headers show

Comments

Marc Glisse - Sept. 3, 2011, 9:05 p.m.
Hello,

this patch is obviously related to PR c++/2316 ("g++ fails to overload on 
language linkage") but seems fairly independent. Currently, the demangler 
recognizes 'Y' for extern "C" functions and ignores it. The patch makes it 
print extern "C" after the function type:
_Z1aIFYviEEvPT_
void a<void (int) extern "C">(void (*)(int) extern "C")

Writing it before the return type seems more natural, but it is ambiguous. 
I guess it could also be printed in the middle (next to the star that 
indicates a function pointer), but placing it like the cv-qualifiers of 
member functions seemed good (plus, that's where Oracle puts it in its 
implementation of c++filt).

Since g++ doesn't generate such mangling, the effect should be hard to 
notice ;-)

(Even if the patch was ok, I am not a committer)

2011-09-03  Marc Glisse  <marc.glisse@inria.fr>

         * include/demangle.h (demangle_component_type)
         [DEMANGLE_COMPONENT_EXTERN_C]: Handle extern "C".
         * libiberty/cp-demangle.c (d_dump): Likewise.
         (d_make_comp): Likewise.
         (d_function_type): Likewise.
         (d_print_comp): Likewise.
         (d_print_mod_list): Likewise.
         (d_print_mod): Likewise.
         (d_print_function_type): Likewise.
         * libiberty/testsuite/demangle-expected: Test it.

Patch

Index: include/demangle.h

===================================================================
--- include/demangle.h	(revision 178498)

+++ include/demangle.h	(working copy)

@@ -288,6 +288,9 @@ 

   /* The const qualifier.  The one subtree is the type which is being
      qualified.  */
   DEMANGLE_COMPONENT_CONST,
+  /* extern "C" linkage.  The one subtree is the function type which

+     is being qualified.  */

+  DEMANGLE_COMPONENT_EXTERN_C,

   /* The restrict qualifier modifying a member function.  The one
      subtree is the type which is being qualified.  */
   DEMANGLE_COMPONENT_RESTRICT_THIS,
Index: libiberty/testsuite/demangle-expected

===================================================================
--- libiberty/testsuite/demangle-expected	(revision 178498)

+++ libiberty/testsuite/demangle-expected	(working copy)

@@ -4151,3 +4151,8 @@ 

 --format=auto
 _ZN3Psi7VariantIIcPKcEE5visitIIRZN11VariantTest9TestVisit11test_methodEvEUlS2_E0_RZNS6_11test_methodEvEUlcE1_RZNS6_11test_methodEvEUlNS_4NoneEE_EEENS_13VariantDetail19SelectVisitorResultIIDpT_EE4typeEDpOSG_
 Psi::VariantDetail::SelectVisitorResult<VariantTest::TestVisit::test_method()::{lambda(char const*)#2}&, VariantTest::TestVisit::test_method()::{lambda(char)#3}&, VariantTest::TestVisit::test_method()::{lambda(Psi::None)#1}&>::type Psi::Variant<char, char const*>::visit<VariantTest::TestVisit::test_method()::{lambda(char const*)#2}&, VariantTest::TestVisit::test_method()::{lambda(char)#3}&, VariantTest::TestVisit::test_method()::{lambda(Psi::None)#1}&>((VariantTest::TestVisit::test_method()::{lambda(Psi::None)#1}&)...)
+#

+# extern "C" linkage for function types.

+--format=gnu-v3

+_Z1aIFYviEEvPT_

+void a<void (int) extern "C">(void (*)(int) extern "C")

Index: libiberty/cp-demangle.c

===================================================================
--- libiberty/cp-demangle.c	(revision 178498)

+++ libiberty/cp-demangle.c	(working copy)

@@ -591,6 +591,9 @@ 

     case DEMANGLE_COMPONENT_CONST:
       printf ("const\n");
       break;
+    case DEMANGLE_COMPONENT_EXTERN_C:

+      printf ("extern \"C\"\n");

+      break;

     case DEMANGLE_COMPONENT_RESTRICT_THIS:
       printf ("restrict this\n");
       break;
@@ -807,6 +810,7 @@ 

       break;
 
       /* These types only require one parameter.  */
+    case DEMANGLE_COMPONENT_EXTERN_C:

     case DEMANGLE_COMPONENT_VTABLE:
     case DEMANGLE_COMPONENT_VTT:
     case DEMANGLE_COMPONENT_TYPEINFO:
@@ -2324,18 +2328,22 @@ 

 d_function_type (struct d_info *di)
 {
   struct demangle_component *ret;
+  int is_extern_c = 0;

 
   if (! d_check_char (di, 'F'))
     return NULL;
   if (d_peek_char (di) == 'Y')
     {
-      /* Function has C linkage.  We don't print this information.

-	 FIXME: We should print it in verbose mode.  */

+      /* Function has C linkage.  */

+      is_extern_c = 1;

       d_advance (di, 1);
+      di->expansion += sizeof "extern \"C\"";

     }
   ret = d_bare_function_type (di, 1);
   if (! d_check_char (di, 'E'))
     return NULL;
+  if (is_extern_c)

+    ret = d_make_comp (di, DEMANGLE_COMPONENT_EXTERN_C, ret, NULL);

   return ret;
 }
 
@@ -3925,6 +3933,7 @@ 

     case DEMANGLE_COMPONENT_RESTRICT_THIS:
     case DEMANGLE_COMPONENT_VOLATILE_THIS:
     case DEMANGLE_COMPONENT_CONST_THIS:
+    case DEMANGLE_COMPONENT_EXTERN_C:

     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
     case DEMANGLE_COMPONENT_POINTER:
     case DEMANGLE_COMPONENT_COMPLEX:
@@ -4537,7 +4546,8 @@ 

       || (! suffix
 	  && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
 	      || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
-	      || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))

+	      || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS

+	      || mods->mod->type == DEMANGLE_COMPONENT_EXTERN_C)))

     {
       d_print_mod_list (dpi, options, mods->next, suffix);
       return;
@@ -4628,6 +4638,9 @@ 

     case DEMANGLE_COMPONENT_CONST_THIS:
       d_append_string (dpi, " const");
       return;
+    case DEMANGLE_COMPONENT_EXTERN_C:

+      d_append_string (dpi, " extern \"C\"");

+      return;

     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
       d_append_char (dpi, ' ');
       d_print_comp (dpi, options, d_right (mod));
@@ -4711,6 +4724,7 @@ 

 	case DEMANGLE_COMPONENT_RESTRICT_THIS:
 	case DEMANGLE_COMPONENT_VOLATILE_THIS:
 	case DEMANGLE_COMPONENT_CONST_THIS:
+	case DEMANGLE_COMPONENT_EXTERN_C:

 	  break;
 	default:
 	  break;