Changeset 642bc83 for src/SymTab/ManglerCommon.cc

Timestamp:

Aug 2, 2018, 11:09:03 AM (5 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

4285544e

Parents:

3bbd012

Message:

Modify name mangling scheme to more closely resembly itanium C++ name mangling

File:

• src/SymTab/ManglerCommon.cc (modified) (1 diff)

src/SymTab/ManglerCommon.cc

@@ -19 +19 @@
 namespace SymTab {
         namespace Mangler {
-                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
-                };
-                const int numBtLetter = sizeof(btLetter)/sizeof(btLetter[0]);
-                static_assert(
-                        numBtLetter == BasicType::NUMBER_OF_BASIC_TYPES,
-                        "Each basic type kind should have a corresponding mangler letter"
-                );
+                namespace Encoding {
+                        const std::string manglePrefix = "_X";
 
-                const std::map<int, const char *> qualifierLetter = {
-                        { Type::Const, "C" },
-                        { Type::Volatile, "V" },
-                        { Type::Atomic, "A" }, // A = Atomic, A0 = Array and forall parameter...
-                        { Type::Mutex, "M" },
-                        { Type::Lvalue, "L" },
-                };
+                        const std::string basicTypes[] = {
+                                "b",  // Bool
+                                "c",  // Char
+                                "a",  // SignedChar
+                                "h",  // UnsignedChar
+                                "s",  // ShortSignedInt
+                                "t",  // ShortUnsignedInt
+                                "i",  // SignedInt
+                                "j",  // UnsignedInt
+                                "l",  // LongSignedInt
+                                "m",  // LongUnsignedInt
+                                "x",  // LongLongSignedInt
+                                "y",  // LongLongUnsignedInt
+                                "f",  // Float
+                                "d",  // Double
+                                "e",  // LongDouble
+                                "Cf", // FloatComplex
+                                "Cd", // DoubleComplex
+                                "Ce", // LongDoubleComplex
+                                // Note: imaginary is not an overloadable type in C++
+                                "If", // FloatImaginary
+                                "Id", // DoubleImaginary
+                                "Ie", // LongDoubleImaginary
+                                "n",  // SignedInt128
+                                "o",  // UnsignedInt128
+                                "Dq",  // Float80 -- TODO: itanium says Float80 and LongDouble both encode to "e", but doing this causes problems with constructing long double, because the cost tables are incorrect
+                                "g",  // Float128
+                                // "z", // ellipsis
+                                // "Dd" // # IEEE 754r decimal floating point (64 bits)
+                                // "De" // # IEEE 754r decimal floating point (128 bits)
+                                // "Df" // # IEEE 754r decimal floating point (32 bits)
+                                // "Dh" // # IEEE 754r half-precision floating point (16 bits)
+                                // "DF"N_ // # ISO/IEC TS 18661 binary floating point type _FloatN (N bits)
+                                // "Di" // char32_t
+                                // "Ds" // char16_t
+                        };
+                        static_assert(
+                                sizeof(basicTypes)/sizeof(basicTypes[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+                                "Each basic type kind should have a corresponding mangler letter"
+                        );
 
-                const std::string nameSeparator = "__cfa__";
+                        const std::map<int, std::string> qualifiers = {
+                                { Type::Const, "C" },
+                                { Type::Volatile, "V" },
+                                { Type::Atomic, "A" }, // A = Atomic, A0 = Array and forall parameter...
+                                { Type::Mutex, "M" },
+                                { Type::Lvalue, "L" },
+                        };
+
+                        const std::string voidType = "v";
+                        const std::string zero = "Z";
+                        const std::string one = "O";
+
+                        const std::string function = "F";
+                        const std::string tuple = "T";
+                        const std::string pointer = "P";
+                        const std::string array = "A";
+                        const std::string qualifiedTypeStart = "N";
+                        const std::string qualifiedTypeEnd = "E";
+
+                        const std::string autogen = "autogen__";
+                        const std::string intrinsic = "intrinsic__";
+                } // namespace Encoding
         } // namespace Mangler
 } // namespace SymTab