Changes in src/SymTab/Mangler.cc [c6b4432:9feb34b]

File:

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

src/SymTab/Mangler.cc

@@ -22 +22 @@
 #include <string>                        // for string, char_traits, operator<<
 
-#include "AST/Pass.hpp"
 #include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
+#include "Common/PassVisitor.h"
 #include "Common/ToString.hpp"           // for toCString
 #include "Common/SemanticError.h"        // for SemanticError
+#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
+#include "SynTree/LinkageSpec.h"         // for Spec, isOverridable, AutoGen, Int...
+#include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
+#include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
+#include "SynTree/Type.h"                // for Type, ReferenceToType, Type::Fora...
+
+#include "AST/Pass.hpp"
+
+namespace SymTab {
+        namespace Mangler {
+                namespace {
+                        /// Mangles names to a unique C identifier
+                        struct Mangler_old : public WithShortCircuiting, public WithVisitorRef<Mangler_old>, public WithGuards {
+                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
+                                Mangler_old( const Mangler_old & ) = delete;
+
+                                void previsit( const BaseSyntaxNode * ) { visit_children = false; }
+
+                                void postvisit( const ObjectDecl * declaration );
+                                void postvisit( const FunctionDecl * declaration );
+                                void postvisit( const TypeDecl * declaration );
+
+                                void postvisit( const VoidType * voidType );
+                                void postvisit( const BasicType * basicType );
+                                void postvisit( const PointerType * pointerType );
+                                void postvisit( const ArrayType * arrayType );
+                                void postvisit( const ReferenceType * refType );
+                                void postvisit( const FunctionType * functionType );
+                                void postvisit( const StructInstType * aggregateUseType );
+                                void postvisit( const UnionInstType * aggregateUseType );
+                                void postvisit( const EnumInstType * aggregateUseType );
+                                void postvisit( const TypeInstType * aggregateUseType );
+                                void postvisit( const TraitInstType * inst );
+                                void postvisit( const TupleType * tupleType );
+                                void postvisit( const VarArgsType * varArgsType );
+                                void postvisit( const ZeroType * zeroType );
+                                void postvisit( const OneType * oneType );
+                                void postvisit( const QualifiedType * qualType );
+
+                                std::string get_mangleName() { return mangleName; }
+                          private:
+                                std::string mangleName;         ///< Mangled name being constructed
+                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
+                                VarMapType varNums;             ///< Map of type variables to indices
+                                int nextVarNum;                 ///< Next type variable index
+                                bool isTopLevel;                ///< Is the Mangler at the top level
+                                bool mangleOverridable;         ///< Specially mangle overridable built-in methods
+                                bool typeMode;                  ///< Produce a unique mangled name for a type
+                                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
+                                bool inFunctionType = false;    ///< Include type qualifiers if false.
+                                bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
+
+                          public:
+                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                                        int nextVarNum, const VarMapType& varNums );
+
+                          private:
+                                void mangleDecl( const DeclarationWithType * declaration );
+                                void mangleRef( const ReferenceToType * refType, std::string prefix );
+
+                                void printQualifiers( const Type *type );
+                        }; // Mangler_old
+                } // namespace
+
+                std::string mangle( const BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
+                        PassVisitor<Mangler_old> mangler( mangleOverridable, typeMode, mangleGenericParams );
+                        maybeAccept( decl, mangler );
+                        return mangler.pass.get_mangleName();
+                }
+
+                std::string mangleType( const Type * ty ) {
+                        PassVisitor<Mangler_old> mangler( false, true, true );
+                        maybeAccept( ty, mangler );
+                        return mangler.pass.get_mangleName();
+                }
+
+                std::string mangleConcrete( const Type * ty ) {
+                        PassVisitor<Mangler_old> mangler( false, false, false );
+                        maybeAccept( ty, mangler );
+                        return mangler.pass.get_mangleName();
+                }
+
+                namespace {
+                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
+                                : nextVarNum( 0 ), isTopLevel( true ),
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ),
+                                mangleGenericParams( mangleGenericParams ) {}
+
+                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                                int nextVarNum, const VarMapType& varNums )
+                                : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ),
+                                mangleGenericParams( mangleGenericParams ) {}
+
+                        void Mangler_old::mangleDecl( const DeclarationWithType * declaration ) {
+                                bool wasTopLevel = isTopLevel;
+                                if ( isTopLevel ) {
+                                        varNums.clear();
+                                        nextVarNum = 0;
+                                        isTopLevel = false;
+                                } // if
+                                mangleName += Encoding::manglePrefix;
+                                const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() );
+                                if ( opInfo ) {
+                                        mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
+                                } else {
+                                        mangleName += std::to_string( declaration->name.size() ) + declaration->name;
+                                } // if
+                                maybeAccept( declaration->get_type(), *visitor );
+                                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
+                                        // want to be able to override autogenerated and intrinsic routines,
+                                        // so they need a different name mangling
+                                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
+                                                mangleName += Encoding::autogen;
+                                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
+                                                mangleName += Encoding::intrinsic;
+                                        } else {
+                                                // if we add another kind of overridable function, this has to change
+                                                assert( false && "unknown overrideable linkage" );
+                                        } // if
+                                }
+                                isTopLevel = wasTopLevel;
+                        }
+
+                        void Mangler_old::postvisit( const ObjectDecl * declaration ) {
+                                mangleDecl( declaration );
+                        }
+
+                        void Mangler_old::postvisit( const FunctionDecl * declaration ) {
+                                mangleDecl( declaration );
+                        }
+
+                        void Mangler_old::postvisit( const VoidType * voidType ) {
+                                printQualifiers( voidType );
+                                mangleName += Encoding::void_t;
+                        }
+
+                        void Mangler_old::postvisit( const BasicType * basicType ) {
+                                printQualifiers( basicType );
+                                assertf( basicType->kind < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
+                                mangleName += Encoding::basicTypes[ basicType->kind ];
+                        }
+
+                        void Mangler_old::postvisit( const PointerType * pointerType ) {
+                                printQualifiers( pointerType );
+                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
+                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName += Encoding::pointer;
+                                maybeAccept( pointerType->base, *visitor );
+                        }
+
+                        void Mangler_old::postvisit( const ArrayType * arrayType ) {
+                                // TODO: encode dimension
+                                printQualifiers( arrayType );
+                                mangleName += Encoding::array + "0";
+                                maybeAccept( arrayType->base, *visitor );
+                        }
+
+                        void Mangler_old::postvisit( const ReferenceType * refType ) {
+                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
+                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
+                                // by pretending every reference type is a function parameter.
+                                GuardValue( inFunctionType );
+                                inFunctionType = true;
+                                printQualifiers( refType );
+                                maybeAccept( refType->base, *visitor );
+                        }
+
+                        namespace {
+                                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
+                                        std::list< Type* > ret;
+                                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
+                                                                        std::mem_fun( &DeclarationWithType::get_type ) );
+                                        return ret;
+                                }
+                        }
+
+                        void Mangler_old::postvisit( const FunctionType * functionType ) {
+                                printQualifiers( functionType );
+                                mangleName += Encoding::function;
+                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
+                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
+                                // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
+                                GuardValue( inFunctionType );
+                                inFunctionType = true;
+                                std::list< Type* > returnTypes = getTypes( functionType->returnVals );
+                                if (returnTypes.empty()) mangleName += Encoding::void_t;
+                                else acceptAll( returnTypes, *visitor );
+                                mangleName += "_";
+                                std::list< Type* > paramTypes = getTypes( functionType->parameters );
+                                acceptAll( paramTypes, *visitor );
+                                mangleName += "_";
+                        }
+
+                        void Mangler_old::mangleRef( const ReferenceToType * refType, std::string prefix ) {
+                                printQualifiers( refType );
+
+                                mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
+
+                                if ( mangleGenericParams ) {
+                                        const std::list< Expression* > & params = refType->parameters;
+                                        if ( ! params.empty() ) {
+                                                mangleName += "_";
+                                                for ( const Expression * param : params ) {
+                                                        const TypeExpr * paramType = dynamic_cast< const TypeExpr * >( param );
+                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
+                                                        maybeAccept( paramType->type, *visitor );
+                                                }
+                                                mangleName += "_";
+                                        }
+                                }
+                        }
+
+                        void Mangler_old::postvisit( const StructInstType * aggregateUseType ) {
+                                mangleRef( aggregateUseType, Encoding::struct_t );
+                        }
+
+                        void Mangler_old::postvisit( const UnionInstType * aggregateUseType ) {
+                                mangleRef( aggregateUseType, Encoding::union_t );
+                        }
+
+                        void Mangler_old::postvisit( const EnumInstType * aggregateUseType ) {
+                                mangleRef( aggregateUseType, Encoding::enum_t );
+                        }
+
+                        void Mangler_old::postvisit( const TypeInstType * typeInst ) {
+                                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
+                                if ( varNum == varNums.end() ) {
+                                        mangleRef( typeInst, Encoding::type );
+                                } else {
+                                        printQualifiers( typeInst );
+                                        // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
+                                        //   forall(dtype T) void f(T);
+                                        //   forall(dtype S) void f(S);
+                                        // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
+                                        // are first found and prefixing with the appropriate encoding for the type class.
+                                        assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
+                                        mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
+                                } // if
+                        }
+
+                        void Mangler_old::postvisit( const TraitInstType * inst ) {
+                                printQualifiers( inst );
+                                mangleName += std::to_string( inst->name.size() ) + inst->name;
+                        }
+
+                        void Mangler_old::postvisit( const TupleType * tupleType ) {
+                                printQualifiers( tupleType );
+                                mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
+                                acceptAll( tupleType->types, *visitor );
+                        }
+
+                        void Mangler_old::postvisit( const VarArgsType * varArgsType ) {
+                                printQualifiers( varArgsType );
+                                static const std::string vargs = "__builtin_va_list";
+                                mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
+                        }
+
+                        void Mangler_old::postvisit( const ZeroType * ) {
+                                mangleName += Encoding::zero;
+                        }
+
+                        void Mangler_old::postvisit( const OneType * ) {
+                                mangleName += Encoding::one;
+                        }
+
+                        void Mangler_old::postvisit( const QualifiedType * qualType ) {
+                                bool inqual = inQualifiedType;
+                                if (! inqual ) {
+                                        // N marks the start of a qualified type
+                                        inQualifiedType = true;
+                                        mangleName += Encoding::qualifiedTypeStart;
+                                }
+                                maybeAccept( qualType->parent, *visitor );
+                                maybeAccept( qualType->child, *visitor );
+                                if ( ! inqual ) {
+                                        // E marks the end of a qualified type
+                                        inQualifiedType = false;
+                                        mangleName += Encoding::qualifiedTypeEnd;
+                                }
+                        }
+
+                        void Mangler_old::postvisit( const TypeDecl * decl ) {
+                                // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
+                                // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
+                                // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
+                                // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
+                                // aside from the assert false.
+                                assertf( false, "Mangler_old should not visit typedecl: %s", toCString(decl));
+                                assertf( decl->kind < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
+                                mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
+                        }
+
+                        __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
+                                for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
+                                        os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
+                                } // for
+                        }
+
+                        void Mangler_old::printQualifiers( const Type * type ) {
+                                // skip if not including qualifiers
+                                if ( typeMode ) return;
+                                if ( ! type->forall.empty() ) {
+                                        std::list< std::string > assertionNames;
+                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
+                                        mangleName += Encoding::forall;
+                                        for ( const TypeDecl * i : type->forall ) {
+                                                switch ( i->kind ) {
+                                                  case TypeDecl::Dtype:
+                                                        dcount++;
+                                                        break;
+                                                  case TypeDecl::Ftype:
+                                                        fcount++;
+                                                        break;
+                                                  case TypeDecl::Ttype:
+                                                        vcount++;
+                                                        break;
+                                                  default:
+                                                        assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[i->kind].c_str() );
+                                                } // switch
+                                                varNums[ i->name ] = std::make_pair( nextVarNum, (int)i->kind );
+                                                for ( const DeclarationWithType * assert : i->assertions ) {
+                                                        PassVisitor<Mangler_old> sub_mangler(
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
+                                                        assert->accept( sub_mangler );
+                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
+                                                        acount++;
+                                                } // for
+                                        } // for
+                                        mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
+                                        for(const auto & a : assertionNames) mangleName += a;
+//                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                                        mangleName += "_";
+                                } // if
+                                if ( ! inFunctionType ) {
+                                        // these qualifiers do not distinguish the outermost type of a function parameter
+                                        if ( type->get_const() ) {
+                                                mangleName += Encoding::qualifiers.at(Type::Const);
+                                        } // if
+                                        if ( type->get_volatile() ) {
+                                                mangleName += Encoding::qualifiers.at(Type::Volatile);
+                                        } // if
+                                        // Removed due to restrict not affecting function compatibility in GCC
+                                        // if ( type->get_isRestrict() ) {
+                                        //      mangleName += "E";
+                                        // } // if
+                                        if ( type->get_atomic() ) {
+                                                mangleName += Encoding::qualifiers.at(Type::Atomic);
+                                        } // if
+                                }
+                                if ( type->get_mutex() ) {
+                                        mangleName += Encoding::qualifiers.at(Type::Mutex);
+                                } // if
+                                if ( inFunctionType ) {
+                                        // turn off inFunctionType so that types can be differentiated for nested qualifiers
+                                        GuardValue( inFunctionType );
+                                        inFunctionType = false;
+                                }
+                        }
+                } // namespace
+        } // namespace Mangler
+} // namespace SymTab
 
 namespace Mangle {
@@ -115 +476 @@
                                 mangleName += std::to_string( decl->name.size() ) + decl->name;
                         } // if
-                        decl->get_type()->accept( *visitor );
+                        maybeAccept( decl->get_type(), *visitor );
                         if ( mangleOverridable && decl->linkage.is_overrideable ) {
                                 // want to be able to override autogenerated and intrinsic routines,
@@ -161 +522 @@
                         printQualifiers( arrayType );
                         mangleName += Encoding::array + "0";
-                        arrayType->base->accept( *visitor );
+                        maybeAccept( arrayType->base.get(), *visitor );
                 }
 
@@ -171 +532 @@
                         inFunctionType = true;
                         printQualifiers( refType );
-                        refType->base->accept( *visitor );
+                        maybeAccept( refType->base.get(), *visitor );
                 }
 
@@ -200 +561 @@
                                         auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
                                         assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
-                                        paramType->type->accept( *visitor );
+                                        maybeAccept( paramType->type.get(), *visitor );
                                 }
                                 mangleName += "_";
@@ -229 +590 @@
                                 // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
                                 // are first found and prefixing with the appropriate encoding for the type class.
-                                assertf( varNum->second.second < ast::TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
+                                assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
                                 mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
                         } // if
@@ -261 +622 @@
                 void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
                         bool inqual = inQualifiedType;
-                        if ( !inqual ) {
+                        if (! inqual ) {
                                 // N marks the start of a qualified type
                                 inQualifiedType = true;
                                 mangleName += Encoding::qualifiedTypeStart;
                         }
-                        qualType->parent->accept( *visitor );
-                        qualType->child->accept( *visitor );
-                        if ( !inqual ) {
+                        maybeAccept( qualType->parent.get(), *visitor );
+                        maybeAccept( qualType->child.get(), *visitor );
+                        if ( ! inqual ) {
                                 // E marks the end of a qualified type
                                 inQualifiedType = false;
@@ -330 +691 @@
                                 // these qualifiers do not distinguish the outermost type of a function parameter
                                 if ( type->is_const() ) {
-                                        mangleName += Encoding::qualifiers.at( ast::CV::Const );
+                                        mangleName += Encoding::qualifiers.at(Type::Const);
                                 } // if
                                 if ( type->is_volatile() ) {
-                                        mangleName += Encoding::qualifiers.at( ast::CV::Volatile );
+                                        mangleName += Encoding::qualifiers.at(Type::Volatile);
                                 } // if
                                 // Removed due to restrict not affecting function compatibility in GCC
@@ -340 +701 @@
                                 // } // if
                                 if ( type->is_atomic() ) {
-                                        mangleName += Encoding::qualifiers.at( ast::CV::Atomic );
+                                        mangleName += Encoding::qualifiers.at(Type::Atomic);
                                 } // if
                         }
                         if ( type->is_mutex() ) {
-                                mangleName += Encoding::qualifiers.at( ast::CV::Mutex );
+                                mangleName += Encoding::qualifiers.at(Type::Mutex);
                         } // if
                         if ( inFunctionType ) {