Changeset 3f7e12cb for src/SymTab/Mangler.cc

Timestamp:

Nov 8, 2017, 5:43:33 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

954908d

Parents:

78315272 (diff), e35f30a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/SymTab/Mangler.cc (modified) (17 diffs)

src/SymTab/Mangler.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:40:29 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Jun 28 15:31:00 2017
-// Update Count     : 21
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Sep 25 15:49:26 2017
+// Update Count     : 23
 //
 #include "Mangler.h"
@@ -31 +31 @@
 
 namespace SymTab {
-        std::string Mangler::mangleType( Type *ty ) {
-                Mangler mangler( false, true );
+        std::string Mangler::mangleType( Type * ty ) {
+                Mangler mangler( false, true, true );
                 maybeAccept( ty, mangler );
                 return mangler.get_mangleName();
         }
 
-        Mangler::Mangler( bool mangleOverridable, bool typeMode )
-                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
+        std::string Mangler::mangleConcrete( Type* ty ) {
+                Mangler mangler( false, false, false );
+                maybeAccept( ty, mangler );
+                return mangler.get_mangleName();
+        }
+
+        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
+                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
 
         Mangler::Mangler( const Mangler &rhs ) : mangleName() {
@@ -48 +54 @@
         }
 
-        void Mangler::mangleDecl( DeclarationWithType *declaration ) {
+        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
                 bool wasTopLevel = isTopLevel;
                 if ( isTopLevel ) {
@@ -79 +85 @@
         }
 
-        void Mangler::visit( ObjectDecl *declaration ) {
+        void Mangler::visit( ObjectDecl * declaration ) {
                 mangleDecl( declaration );
         }
 
-        void Mangler::visit( FunctionDecl *declaration ) {
+        void Mangler::visit( FunctionDecl * declaration ) {
                 mangleDecl( declaration );
         }
 
-        void Mangler::visit( VoidType *voidType ) {
+        void Mangler::visit( VoidType * voidType ) {
                 printQualifiers( voidType );
                 mangleName << "v";
         }
 
-        void Mangler::visit( BasicType *basicType ) {
+        void Mangler::visit( BasicType * basicType ) {
                 static const char *btLetter[] = {
                         "b",    // Bool
@@ -115 +121 @@
                         "Id",   // DoubleImaginary
                         "Ir",   // LongDoubleImaginary
+                        "w",    // SignedInt128
+                        "Uw",   // UnsignedInt128
                 };
 
@@ -121 +129 @@
         }
 
-        void Mangler::visit( PointerType *pointerType ) {
+        void Mangler::visit( PointerType * pointerType ) {
                 printQualifiers( pointerType );
                 mangleName << "P";
@@ -127 +135 @@
         }
 
-        void Mangler::visit( ArrayType *arrayType ) {
+        void Mangler::visit( ArrayType * arrayType ) {
                 // TODO: encode dimension
                 printQualifiers( arrayType );
@@ -134 +142 @@
         }
 
-        void Mangler::visit( ReferenceType *refType ) {
+        void Mangler::visit( ReferenceType * refType ) {
                 printQualifiers( refType );
                 mangleName << "R";
@@ -149 +157 @@
         }
 
-        void Mangler::visit( FunctionType *functionType ) {
+        void Mangler::visit( FunctionType * functionType ) {
                 printQualifiers( functionType );
                 mangleName << "F";
@@ -160 +168 @@
         }
 
-        void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
+        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
                 printQualifiers( refType );
 
                 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
-        }
-
-        void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
-                printQualifiers( refType );
-
-                std::ostringstream oldName( mangleName.str() );
-                mangleName.clear();
-
-                mangleName << prefix << refType->get_name();
-
-                std::list< Expression* >& params = refType->get_parameters();
-                if ( ! params.empty() ) {
-                        mangleName << "_";
-                        for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
-                                maybeAccept( paramType->get_type(), *this );
+
+                if ( mangleGenericParams ) {
+                        std::list< Expression* >& params = refType->get_parameters();
+                        if ( ! params.empty() ) {
+                                mangleName << "_";
+                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
+                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
+                                        maybeAccept( paramType->get_type(), *this );
+                                }
+                                mangleName << "_";
                         }
-                        mangleName << "_";
                 }
-
-                oldName << mangleName.str().length() << mangleName.str();
-                mangleName.str( oldName.str() );
-        }
-
-        void Mangler::visit( StructInstType *aggregateUseType ) {
-                if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
-                else mangleRef( aggregateUseType, "s" );
-        }
-
-        void Mangler::visit( UnionInstType *aggregateUseType ) {
-                if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
-                else mangleRef( aggregateUseType, "u" );
-        }
-
-        void Mangler::visit( EnumInstType *aggregateUseType ) {
+        }
+
+        void Mangler::visit( StructInstType * aggregateUseType ) {
+                mangleRef( aggregateUseType, "s" );
+        }
+
+        void Mangler::visit( UnionInstType * aggregateUseType ) {
+                mangleRef( aggregateUseType, "u" );
+        }
+
+        void Mangler::visit( EnumInstType * aggregateUseType ) {
                 mangleRef( aggregateUseType, "e" );
         }
 
-        void Mangler::visit( TypeInstType *typeInst ) {
+        void Mangler::visit( TypeInstType * typeInst ) {
                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                 if ( varNum == varNums.end() ) {
@@ -212 +208 @@
                         numStream << varNum->second.first;
                         switch ( (TypeDecl::Kind )varNum->second.second ) {
-                          case TypeDecl::Any:
-                                mangleName << "t";
-                                break;
                           case TypeDecl::Dtype:
                                 mangleName << "d";
@@ -231 +224 @@
         }
 
-        void Mangler::visit( TupleType *tupleType ) {
+        void Mangler::visit( TupleType * tupleType ) {
                 printQualifiers( tupleType );
                 mangleName << "T";
-                acceptAll( tupleType->get_types(), *this );
+                acceptAll( tupleType->types, *this );
                 mangleName << "_";
         }
 
-        void Mangler::visit( VarArgsType *varArgsType ) {
+        void Mangler::visit( VarArgsType * varArgsType ) {
                 printQualifiers( varArgsType );
                 mangleName << "VARGS";
         }
 
-        void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
+        void Mangler::visit( ZeroType * ) {
                 mangleName << "Z";
         }
 
-        void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
+        void Mangler::visit( OneType * ) {
                 mangleName << "O";
         }
 
-        void Mangler::visit( TypeDecl *decl ) {
+        void Mangler::visit( TypeDecl * decl ) {
                 static const char *typePrefix[] = { "BT", "BD", "BF" };
-                mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
         }
 
@@ -262 +255 @@
         }
 
-        void Mangler::printQualifiers( Type *type ) {
+        void Mangler::printQualifiers( Type * type ) {
                 // skip if not including qualifiers
                 if ( typeMode ) return;
@@ -270 +263 @@
                         int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
                         mangleName << "A";
-                        for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                 switch ( (*i)->get_kind() ) {
-                                  case TypeDecl::Any:
-                                        tcount++;
-                                        break;
                                   case TypeDecl::Dtype:
                                         dcount++;
@@ -287 +277 @@
                                         assert( false );
                                 } // switch
-                                varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
-                                for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
-                                        Mangler sub_mangler( mangleOverridable, typeMode );
+                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
+                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
+                                        Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
                                         sub_mangler.nextVarNum = nextVarNum;
                                         sub_mangler.isTopLevel = false;
@@ -307 +297 @@
                         mangleName << "V";
                 } // if
+                if ( type->get_mutex() ) {
+                        mangleName << "M";
+                } // if
                 // Removed due to restrict not affecting function compatibility in GCC
 //              if ( type->get_isRestrict() ) {
@@ -312 +305 @@
 //              } // if
                 if ( type->get_lvalue() ) {
+                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
                         mangleName << "L";
-                } // if
+                }
                 if ( type->get_atomic() ) {
                         mangleName << "A";