Changeset b067d9b for src/SymTab/Mangler.h

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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.h (modified) (1 diff)

src/SymTab/Mangler.h

@@ -21 +21 @@
 #include <utility>            // for pair
 
+#include "AST/Bitfield.hpp"
+#include "AST/Fwd.hpp"
 #include "SynTree/SynTree.h"  // for Types
 #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 ResolvExpr {
+        class TypeEnvironment;
+}
 
 namespace SymTab {
         namespace Mangler {
                 /// Mangle syntax tree object; primary interface to clients
-                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
+                std::string mangle( const BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
 
                 /// Mangle a type name; secondary interface
-                std::string mangleType( Type* ty );
+                std::string mangleType( const Type * ty );
                 /// Mangle ignoring generic type parameters
-                std::string mangleConcrete( Type* ty );
+                std::string mangleConcrete( const Type * ty );
+
+                namespace Encoding {
+                        extern const std::string manglePrefix;
+                        extern const std::string basicTypes[];
+                        extern const std::map<int, std::string> qualifiers;
+
+                        extern const std::string void_t;
+                        extern const std::string zero;
+                        extern const std::string one;
+
+                        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;
+
+                        extern const std::string forall;
+                        extern const std::string typeVariables[];
+
+                        extern const std::string struct_t;
+                        extern const std::string union_t;
+                        extern const std::string enum_t;
+                        extern const std::string type;
+
+                        extern const std::string autogen;
+                        extern const std::string intrinsic;
+                };
         } // Mangler
 } // SymTab
+
+namespace Mangle {
+        /// Bitflags for mangle modes
+        enum {
+                NoOverrideable  = 1 << 0,
+                Type            = 1 << 1,
+                NoGenericParams = 1 << 2
+        };
+
+        /// Bitflag type for mangler modes
+        struct mangle_flags {
+                union {
+                        unsigned int val;
+                        struct {
+                                bool no_overrideable   : 1;
+                                bool type              : 1;
+                                bool no_generic_params : 1;
+                        };
+                };
+
+                constexpr mangle_flags( unsigned int val ) : val(val) {}
+        };
+
+        using Mode = bitfield<mangle_flags>;
+
+        static inline Mode typeMode() { return NoOverrideable | Type; }
+
+        /// Mangle declaration name
+        std::string mangle( const ast::Node * decl, Mode mode = {} );
+
+        namespace Encoding {
+                using namespace SymTab::Mangler::Encoding;
+        };
+}
+
+extern "C" {
+        char * cforall_demangle(const char *, int);
+}
 
 // Local Variables: //