Changeset 0e73845

Timestamp:

Aug 19, 2018, 12:09:00 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

04c77791

Parents:

38587bc

Message:

Fix name mangling for type variables and forall lists

Location:

src

Files:

• SymTab/Mangler.cc (modified) (5 diffs)
• SymTab/Mangler.h (modified) (1 diff)
• SymTab/ManglerCommon.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (1 diff)

src/SymTab/Mangler.cc

@@ -149 +149 @@
                         void Mangler::postvisit( BasicType * basicType ) {
                                 printQualifiers( basicType );
-                                assert( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES );
+                                assertf( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->get_kind() );
                                 mangleName << Encoding::basicTypes[ basicType->get_kind() ];
                         }
@@ -240 +240 @@
                                 } else {
                                         printQualifiers( typeInst );
-                                        std::ostringstream numStream;
-                                        numStream << varNum->second.first;
-                                        switch ( (TypeDecl::Kind )varNum->second.second ) {
-                                          case TypeDecl::Dtype:
-                                                mangleName << "d";
-                                                break;
-                                          case TypeDecl::Ftype:
-                                                mangleName << "f";
-                                                break;
-                                                case TypeDecl::Ttype:
-                                                mangleName << "tVARGS";
-                                                break;
-                                                default:
-                                                assert( false );
-                                        } // switch
-                                        mangleName << numStream.str();
+                                        assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
+                                        mangleName << Encoding::typeVariables[varNum->second.second] << typeInst->get_name().size() << typeInst->get_name(); // varNum->second.first;
                                 } // if
                         }
@@ -301 +287 @@
 
                         void Mangler::postvisit( TypeDecl * decl ) {
-                                static const char *typePrefix[] = { "BT", "BD", "BF" };
-                                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
+                                assertf( decl->get_kind() < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->get_kind() );
+                                mangleName << Encoding::typeVariables[ decl->get_kind() ] << ( decl->name.length() ) << decl->name;
                         }
 
@@ -316 +302 @@
                                 if ( ! type->get_forall().empty() ) {
                                         std::list< std::string > assertionNames;
-                                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
-                                        mangleName << "A";
+                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
+                                        mangleName << Encoding::forall;
                                         for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                                 switch ( (*i)->get_kind() ) {
@@ -340 +326 @@
                                                         (*assert)->accept( sub_mangler );
                                                         assertionNames.push_back( sub_mangler.pass.mangleName.str() );
+                                                        acount++;
                                                 } // for
                                         } // for
-                                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
+                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
                                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
                                         mangleName << "_";

src/SymTab/Mangler.h

@@ -57 +57 @@
                         extern const std::string qualifiedTypeEnd;
 
+                        extern const std::string forall;
+                        extern const std::string typeVariables[];
+
                         extern const std::string struct_t;
                         extern const std::string union_t;

src/SymTab/ManglerCommon.cc

@@ -16 +16 @@
 #include "Mangler.h"
 #include "SynTree/Type.h"
+#include "SynTree/Declaration.h"
 
 namespace SymTab {
@@ -82 +83 @@
                         const std::string qualifiedTypeEnd = "E";
 
+                        const std::string forall = "Q";
+                        const std::string typeVariables[] = {
+                                "BD", // dtype
+                                "BF", // ftype
+                                "BT", // ttype
+                        };
+                        static_assert(
+                                sizeof(typeVariables)/sizeof(typeVariables[0]) == TypeDecl::NUMBER_OF_KINDS,
+                                "Each type variable kind should have a corresponding mangler prefix"
+                        );
+
                         const std::string struct_t = "S";
                         const std::string union_t = "U";

src/SynTree/Declaration.h

@@ -202 +202 @@
         typedef NamedTypeDecl Parent;
   public:
-        enum Kind { Dtype, Ftype, Ttype };
+        enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS };
 
         Type * init;