Changes in src/SymTab/Mangler.cc [0e761e40:e73becf]

File:

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

src/SymTab/Mangler.cc

@@ -73 +73 @@
                                 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
 
                                 void mangleDecl( DeclarationWithType *declaration );
@@ -111 +110 @@
                                         isTopLevel = false;
                                 } // if
-                                mangleName << Encoding::manglePrefix;
+                                mangleName << "__";
                                 CodeGen::OperatorInfo opInfo;
                                 if ( operatorLookup( declaration->get_name(), opInfo ) ) {
-                                        mangleName << opInfo.outputName.size() << opInfo.outputName;
+                                        mangleName << opInfo.outputName;
                                 } else {
-                                        mangleName << declaration->name.size() << declaration->name;
+                                        mangleName << declaration->get_name();
                                 } // if
+                                mangleName << "__";
                                 maybeAccept( declaration->get_type(), *visitor );
                                 if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
@@ -123 +123 @@
                                         // so they need a different name mangling
                                         if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
-                                                mangleName << Encoding::autogen;
+                                                mangleName << "autogen__";
                                         } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                mangleName << Encoding::intrinsic;
+                                                mangleName << "intrinsic__";
                                         } else {
                                                 // if we add another kind of overridable function, this has to change
@@ -144 +144 @@
                         void Mangler::postvisit( VoidType * voidType ) {
                                 printQualifiers( voidType );
-                                mangleName << Encoding::void_t;
+                                mangleName << "v";
                         }
 
                         void Mangler::postvisit( BasicType * basicType ) {
+                                static const char *btLetter[] = {
+                                        "b",    // Bool
+                                        "c",    // Char
+                                        "Sc",   // SignedChar
+                                        "Uc",   // UnsignedChar
+                                        "s",    // ShortSignedInt
+                                        "Us",   // ShortUnsignedInt
+                                        "i",    // SignedInt
+                                        "Ui",   // UnsignedInt
+                                        "l",    // LongSignedInt
+                                        "Ul",   // LongUnsignedInt
+                                        "q",    // LongLongSignedInt
+                                        "Uq",   // LongLongUnsignedInt
+                                        "f",    // Float
+                                        "d",    // Double
+                                        "r",    // LongDouble
+                                        "Xf",   // FloatComplex
+                                        "Xd",   // DoubleComplex
+                                        "Xr",   // LongDoubleComplex
+                                        "If",   // FloatImaginary
+                                        "Id",   // DoubleImaginary
+                                        "Ir",   // LongDoubleImaginary
+                                        "w",    // SignedInt128
+                                        "Uw",   // UnsignedInt128
+                                        "x",    // Float80
+                                        "y",    // Float128
+                                };
+                                static_assert(
+                                        sizeof(btLetter)/sizeof(btLetter[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+                                        "Each basic type kind should have a corresponding mangler letter"
+                                );
+
                                 printQualifiers( basicType );
-                                assertf( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->get_kind() );
-                                mangleName << Encoding::basicTypes[ basicType->get_kind() ];
+                                assert( basicType->get_kind() < sizeof(btLetter)/sizeof(btLetter[0]) );
+                                mangleName << btLetter[ basicType->get_kind() ];
                         }
 
@@ -156 +188 @@
                                 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;
+                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << "P";
                                 maybeAccept( pointerType->base, *visitor );
                         }
@@ -163 +195 @@
                                 // TODO: encode dimension
                                 printQualifiers( arrayType );
-                                mangleName << Encoding::array << "0";
+                                mangleName << "A0";
                                 maybeAccept( arrayType->base, *visitor );
                         }
@@ -188 +220 @@
                         void Mangler::postvisit( FunctionType * functionType ) {
                                 printQualifiers( functionType );
-                                mangleName << Encoding::function;
+                                mangleName << "F";
                                 // 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.,
@@ -195 +227 @@
                                 inFunctionType = true;
                                 std::list< Type* > returnTypes = getTypes( functionType->returnVals );
-                                if (returnTypes.empty()) mangleName << Encoding::void_t;
-                                else acceptAll( returnTypes, *visitor );
+                                acceptAll( returnTypes, *visitor );
                                 mangleName << "_";
                                 std::list< Type* > paramTypes = getTypes( functionType->parameters );
@@ -206 +237 @@
                                 printQualifiers( refType );
 
-                                mangleName << prefix << refType->name.length() << refType->name;
+                                mangleName << ( refType->name.length() + prefix.length() ) << prefix << refType->name;
 
                                 if ( mangleGenericParams ) {
@@ -223 +254 @@
 
                         void Mangler::postvisit( StructInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, Encoding::struct_t );
+                                mangleRef( aggregateUseType, "s" );
                         }
 
                         void Mangler::postvisit( UnionInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, Encoding::union_t );
+                                mangleRef( aggregateUseType, "u" );
                         }
 
                         void Mangler::postvisit( EnumInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, Encoding::enum_t );
+                                mangleRef( aggregateUseType, "e" );
                         }
 
@@ -237 +268 @@
                                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                                 if ( varNum == varNums.end() ) {
-                                        mangleRef( typeInst, Encoding::type );
+                                        mangleRef( typeInst, "t" );
                                 } 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] << varNum->second.first;
+                                        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();
                                 } // if
                         }
@@ -252 +292 @@
                         void Mangler::postvisit( TraitInstType * inst ) {
                                 printQualifiers( inst );
-                                mangleName << inst->name.size() << inst->name;
+                                mangleName << "_Y" << inst->name << "_";
                         }
 
                         void Mangler::postvisit( TupleType * tupleType ) {
                                 printQualifiers( tupleType );
-                                mangleName << Encoding::tuple << tupleType->types.size();
+                                mangleName << "T";
                                 acceptAll( tupleType->types, *visitor );
+                                mangleName << "_";
                         }
 
                         void Mangler::postvisit( VarArgsType * varArgsType ) {
                                 printQualifiers( varArgsType );
-                                static const std::string vargs = "__builtin_va_list";
-                                mangleName << Encoding::type << vargs.size() << vargs;
+                                mangleName << "VARGS";
                         }
 
                         void Mangler::postvisit( ZeroType * ) {
-                                mangleName << Encoding::zero;
+                                mangleName << "Z";
                         }
 
                         void Mangler::postvisit( OneType * ) {
-                                mangleName << Encoding::one;
+                                mangleName << "O";
                         }
 
                         void Mangler::postvisit( QualifiedType * qualType ) {
-                                bool inqual = inQualifiedType;
-                                if (! inqual ) {
-                                        // N marks the start of a qualified type
-                                        inQualifiedType = true;
-                                        mangleName << Encoding::qualifiedTypeStart;
-                                }
                                 maybeAccept( qualType->parent, *visitor );
+                                mangleName << "__";
                                 maybeAccept( qualType->child, *visitor );
-                                if ( ! inqual ) {
-                                        // E marks the end of a qualified type
-                                        inQualifiedType = false;
-                                        mangleName << Encoding::qualifiedTypeEnd;
-                                }
                         }
 
                         void Mangler::postvisit( 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 should not visit typedecl: %s", toCString(decl));
-                                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;
+                                static const char *typePrefix[] = { "BT", "BD", "BF" };
+                                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
                         }
 
@@ -313 +337 @@
                                 if ( ! type->get_forall().empty() ) {
                                         std::list< std::string > assertionNames;
-                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
-                                        mangleName << Encoding::forall;
+                                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
+                                        mangleName << "A";
                                         for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                                 switch ( (*i)->get_kind() ) {
@@ -337 +361 @@
                                                         (*assert)->accept( sub_mangler );
                                                         assertionNames.push_back( sub_mangler.pass.mangleName.str() );
-                                                        acount++;
                                                 } // for
                                         } // for
-                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
+                                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
                                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
                                         mangleName << "_";
@@ -347 +370 @@
                                         // these qualifiers do not distinguish the outermost type of a function parameter
                                         if ( type->get_const() ) {
-                                                mangleName << Encoding::qualifiers.at(Type::Const);
+                                                mangleName << "C";
                                         } // if
                                         if ( type->get_volatile() ) {
-                                                mangleName << Encoding::qualifiers.at(Type::Volatile);
+                                                mangleName << "V";
                                         } // if
                                         // Removed due to restrict not affecting function compatibility in GCC
@@ -357 +380 @@
                                         // } // if
                                         if ( type->get_atomic() ) {
-                                                mangleName << Encoding::qualifiers.at(Type::Atomic);
+                                                mangleName << "A";
                                         } // if
                                 }
                                 if ( type->get_mutex() ) {
-                                        mangleName << Encoding::qualifiers.at(Type::Mutex);
+                                        mangleName << "M";
                                 } // if
                                 if ( type->get_lvalue() ) {
                                         // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
-                                        mangleName << Encoding::qualifiers.at(Type::Lvalue);
+                                        mangleName << "L";
                                 }