Changeset 90152a4 for src/SymTab/Mangler.h

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

File:

• src/SymTab/Mangler.h (modified) (1 diff)

src/SymTab/Mangler.h

@@ -24 +24 @@
 #include "SynTree/Visitor.h"  // for Visitor, maybeAccept
 
+// https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
+// The CFA name mangling scheme is based closely on the itanium C++ name mangling scheme, with the following key differences:
+// * Variable names are also mangled to include type information, not just functions
+// * CFA does not have template expansion, so the rules for function specialization do not apply.
+// * CFA instead has to handle type parameters and assertion parameters.
+// * Currently name compression is not implemented.
+
 namespace SymTab {
-        /// Mangles names to a unique C identifier
-        class Mangler : public Visitor {
-          public:
+        namespace Mangler {
                 /// Mangle syntax tree object; primary interface to clients
-                template< typename SynTreeClass >
-            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
+                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
+
                 /// Mangle a type name; secondary interface
-                static std::string mangleType( Type* ty );
+                std::string mangleType( Type* ty );
                 /// Mangle ignoring generic type parameters
-                static std::string mangleConcrete( Type* ty );
+                std::string mangleConcrete( Type* ty );
 
+                namespace Encoding {
+                        extern const std::string manglePrefix;
+                        extern const std::string basicTypes[];
+                        extern const std::map<int, std::string> qualifiers;
 
-                virtual void visit( ObjectDecl *declaration );
-                virtual void visit( FunctionDecl *declaration );
-                virtual void visit( TypeDecl *declaration );
+                        extern const std::string void_t;
+                        extern const std::string zero;
+                        extern const std::string one;
 
-                virtual void visit( VoidType *voidType );
-                virtual void visit( BasicType *basicType );
-                virtual void visit( PointerType *pointerType );
-                virtual void visit( ArrayType *arrayType );
-                virtual void visit( ReferenceType *refType );
-                virtual void visit( FunctionType *functionType );
-                virtual void visit( StructInstType *aggregateUseType );
-                virtual void visit( UnionInstType *aggregateUseType );
-                virtual void visit( EnumInstType *aggregateUseType );
-                virtual void visit( TypeInstType *aggregateUseType );
-                virtual void visit( TupleType *tupleType );
-                virtual void visit( VarArgsType *varArgsType );
-                virtual void visit( ZeroType *zeroType );
-                virtual void visit( OneType *oneType );
+                        extern const std::string function;
+                        extern const std::string tuple;
+                        extern const std::string pointer;
+                        extern const std::string array;
+                        extern const std::string qualifiedTypeStart;
+                        extern const std::string qualifiedTypeEnd;
 
-                std::string get_mangleName() { return mangleName.str(); }
-          private:
-                std::ostringstream 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
+                        extern const std::string forall;
+                        extern const std::string typeVariables[];
 
-                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
-                Mangler( const Mangler & );
+                        extern const std::string struct_t;
+                        extern const std::string union_t;
+                        extern const std::string enum_t;
+                        extern const std::string type;
 
-                void mangleDecl( DeclarationWithType *declaration );
-                void mangleRef( ReferenceToType *refType, std::string prefix );
+                        extern const std::string autogen;
+                        extern const std::string intrinsic;
+                };
+        } // Mangler
+} // SymTab
 
-                void printQualifiers( Type *type );
-        }; // Mangler
-
-        template< typename SynTreeClass >
-        std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
-                Mangler mangler( mangleOverridable, typeMode, mangleGenericParams );
-                maybeAccept( decl, mangler );
-                return mangler.get_mangleName();
-        }
-} // SymTab
+extern "C" {
+        char * cforall_demangle(const char *, int);
+}
 
 // Local Variables: //