Changeset 85d44c6 for src/SymTab

Timestamp:

Feb 14, 2019, 10:23:51 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

fba51ab

Parents:

6d01d89 (diff), e15853c (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:

fix conflict

File:

• src/SymTab/ManglerCommon.cc (modified) (4 diffs)

src/SymTab/ManglerCommon.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:45:30 2017
-// Update Count     : 15
+// Last Modified On : Thu Feb 14 08:12:17 2019
+// Update Count     : 25
 //
 
@@ -22 +22 @@
                 namespace Encoding {
                         const std::string manglePrefix = "_X";
-
+#if 0
                         const std::string basicTypes[] = {
                                 "b",  // Bool
@@ -43 +43 @@
                                 "Ce", // LongDoubleComplex
                                 // Note: imaginary is not an overloadable type in C++
-                                "If", // FloatImaginary
-                                "Id", // DoubleImaginary
-                                "Ie", // LongDoubleImaginary
+                                // "If", // FloatImaginary
+                                // "Id", // DoubleImaginary
+                                // "Ie", // LongDoubleImaginary
                                 "n",  // SignedInt128
                                 "o",  // UnsignedInt128
@@ -63 +63 @@
                                 "Each basic type kind should have a corresponding mangler letter"
                         );
+#endif
+                        // GENERATED START, DO NOT EDIT
+                        // NOTES ON MANGLING:
+                        // * Itanium spec says that Float80 encodes to "e" (like LongDouble), but the distinct lengths cause resolution problems.
+                        // * Float128 is supposed to encode to "g", but I wanted it to mangle equal to LongDouble.
+                        // * Mangling for non-standard complex types is by best guess
+                        // * _FloatN is supposed to encode as "DF"N"_"; modified for same reason as above.
+                        // * unused mangling identifiers:
+                        //   - "z" ellipsis
+                        //   - "Dd" IEEE 754r 64-bit decimal floating point (borrowed for _Float32x)
+                        //   - "De" IEEE 754r 128-bit decimal floating point
+                        //   - "Df" IEEE 754r 32-bit decimal floating point
+                        //   - "Dh" IEEE 754r 16-bit decimal floating point (borrowed for _Float16)
+                        //   - "DF"N"_" ISO/IEC TS 18661 N-bit binary floating point (_FloatN)
+                        //   - "Di" char32_t
+                        //   - "Ds" char16_t
+                        const std::string basicTypes[BasicType::NUMBER_OF_BASIC_TYPES] = {
+                                "b",        // _Bool
+                                "c",        // char
+                                "a",        // signed char
+                                "h",        // unsigned char
+                                "s",        // signed short int
+                                "t",        // unsigned short int
+                                "i",        // signed int
+                                "j",        // unsigned int
+                                "l",        // signed long int
+                                "m",        // unsigned long int
+                                "x",        // signed long long int
+                                "y",        // unsigned long long int
+                                "n",        // __int128
+                                "o",        // unsigned __int128
+                                "DF16_",    // _Float16
+                                "CDF16_",   // _Float16 _Complex
+                                "DF32_",    // _Float32
+                                "CDF32_",   // _Float32 _Complex
+                                "f",        // float
+                                "Cf",       // float _Complex
+                                "DF32x_",   // _Float32x
+                                "CDF32x_",  // _Float32x _Complex
+                                "DF64_",    // _Float64
+                                "CDF64_",   // _Float64 _Complex
+                                "d",        // double
+                                "Cd",       // double _Complex
+                                "DF64x_",   // _Float64x
+                                "CDF64x_",  // _Float64x _Complex
+                                "Dq",       // __float80
+                                "DF128_",   // _Float128
+                                "CDF128_",  // _Float128 _Complex
+                                "g",        // __float128
+                                "e",        // long double
+                                "Ce",       // long double _Complex
+                                "DF128x_",  // _Float128x
+                                "CDF128x_", // _Float128x _Complex
+                        }; // basicTypes
+                        // GENERATED END
 
                         const std::map<int, std::string> qualifiers = {