Jim Stichnoth | 98ba006 | 2016-03-07 09:26:22 -0800 | [diff] [blame] | 1 | //===- subzero/src/IceMangling.cpp - Cross test name mangling --*- C++ -*-===// |
| 2 | // |
| 3 | // The Subzero Code Generator |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | /// |
| 10 | /// \file |
| 11 | /// \brief Defines utility functions for name mangling for cross tests. |
| 12 | /// |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "IceDefs.h" |
| 16 | #include "IceGlobalContext.h" |
| 17 | #include "IceMangling.h" |
| 18 | |
| 19 | #include <cctype> // isdigit(), isupper() |
| 20 | #include <locale> // locale |
| 21 | |
| 22 | namespace Ice { |
| 23 | |
| 24 | using ManglerVector = llvm::SmallVector<char, 32>; |
| 25 | |
| 26 | namespace { |
| 27 | |
| 28 | // Scan a string for S[0-9A-Z]*_ patterns and replace them with |
| 29 | // S<num>_ where <num> is the next base-36 value. If a type name |
| 30 | // legitimately contains that pattern, then the substitution will be |
| 31 | // made in error and most likely the link will fail. In this case, |
| 32 | // the test classes can be rewritten not to use that pattern, which is |
| 33 | // much simpler and more reliable than implementing a full demangling |
| 34 | // parser. Another substitution-in-error may occur if a type |
| 35 | // identifier ends with the pattern S[0-9A-Z]*, because an immediately |
| 36 | // following substitution string like "S1_" or "PS1_" may be combined |
| 37 | // with the previous type. |
| 38 | void incrementSubstitutions(ManglerVector &OldName) { |
| 39 | const std::locale CLocale("C"); |
| 40 | // Provide extra space in case the length of <num> increases. |
| 41 | ManglerVector NewName(OldName.size() * 2); |
| 42 | size_t OldPos = 0; |
| 43 | size_t NewPos = 0; |
| 44 | const size_t OldLen = OldName.size(); |
| 45 | for (; OldPos < OldLen; ++OldPos, ++NewPos) { |
| 46 | if (OldName[OldPos] == '\0') |
| 47 | break; |
| 48 | if (OldName[OldPos] == 'S') { |
| 49 | // Search forward until we find _ or invalid character (including \0). |
| 50 | bool AllZs = true; |
| 51 | bool Found = false; |
| 52 | size_t Last; |
| 53 | for (Last = OldPos + 1; Last < OldLen; ++Last) { |
| 54 | char Ch = OldName[Last]; |
| 55 | if (Ch == '_') { |
| 56 | Found = true; |
| 57 | break; |
| 58 | } else if (std::isdigit(Ch) || std::isupper(Ch, CLocale)) { |
| 59 | if (Ch != 'Z') |
| 60 | AllZs = false; |
| 61 | } else { |
| 62 | // Invalid character, stop searching. |
| 63 | break; |
| 64 | } |
| 65 | } |
| 66 | if (Found) { |
| 67 | NewName[NewPos++] = OldName[OldPos++]; // 'S' |
| 68 | size_t Length = Last - OldPos; |
| 69 | // NewPos and OldPos point just past the 'S'. |
| 70 | assert(NewName[NewPos - 1] == 'S'); |
| 71 | assert(OldName[OldPos - 1] == 'S'); |
| 72 | assert(OldName[OldPos + Length] == '_'); |
| 73 | if (AllZs) { |
| 74 | // Replace N 'Z' characters with a '0' (if N=0) or '1' (if N>0) |
| 75 | // followed by N '0' characters. |
| 76 | NewName[NewPos++] = (Length ? '1' : '0'); |
| 77 | for (size_t i = 0; i < Length; ++i) { |
| 78 | NewName[NewPos++] = '0'; |
| 79 | } |
| 80 | } else { |
| 81 | // Iterate right-to-left and increment the base-36 number. |
| 82 | bool Carry = true; |
| 83 | for (size_t i = 0; i < Length; ++i) { |
| 84 | size_t Offset = Length - 1 - i; |
| 85 | char Ch = OldName[OldPos + Offset]; |
| 86 | if (Carry) { |
| 87 | Carry = false; |
| 88 | switch (Ch) { |
| 89 | case '9': |
| 90 | Ch = 'A'; |
| 91 | break; |
| 92 | case 'Z': |
| 93 | Ch = '0'; |
| 94 | Carry = true; |
| 95 | break; |
| 96 | default: |
| 97 | ++Ch; |
| 98 | break; |
| 99 | } |
| 100 | } |
| 101 | NewName[NewPos + Offset] = Ch; |
| 102 | } |
| 103 | NewPos += Length; |
| 104 | } |
| 105 | OldPos = Last; |
| 106 | // Fall through and let the '_' be copied across. |
| 107 | } |
| 108 | } |
| 109 | NewName[NewPos] = OldName[OldPos]; |
| 110 | } |
| 111 | assert(NewName[NewPos] == '\0'); |
| 112 | OldName = NewName; |
| 113 | } |
| 114 | |
| 115 | } // end of anonymous namespace |
| 116 | |
| 117 | // In this context, name mangling means to rewrite a symbol using a given |
| 118 | // prefix. For a C++ symbol, nest the original symbol inside the "prefix" |
| 119 | // namespace. For other symbols, just prepend the prefix. |
Jim Stichnoth | 467ffe5 | 2016-03-29 15:01:06 -0700 | [diff] [blame] | 120 | std::string mangleName(const std::string &Name) { |
Jim Stichnoth | 98ba006 | 2016-03-07 09:26:22 -0800 | [diff] [blame] | 121 | // An already-nested name like foo::bar() gets pushed down one level, making |
| 122 | // it equivalent to Prefix::foo::bar(). |
| 123 | // _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz |
| 124 | // A non-nested but mangled name like bar() gets nested, making it equivalent |
| 125 | // to Prefix::bar(). |
| 126 | // _Z3barxyz ==> ZN6Prefix3barExyz |
| 127 | // An unmangled, extern "C" style name, gets a simple prefix: |
| 128 | // bar ==> Prefixbar |
Karl Schimpf | d469994 | 2016-04-02 09:55:31 -0700 | [diff] [blame] | 129 | if (!BuildDefs::dump() || getFlags().getTestPrefix().empty()) |
Jim Stichnoth | 98ba006 | 2016-03-07 09:26:22 -0800 | [diff] [blame] | 130 | return Name; |
| 131 | |
Karl Schimpf | d469994 | 2016-04-02 09:55:31 -0700 | [diff] [blame] | 132 | const std::string TestPrefix = getFlags().getTestPrefix(); |
Jim Stichnoth | 98ba006 | 2016-03-07 09:26:22 -0800 | [diff] [blame] | 133 | unsigned PrefixLength = TestPrefix.length(); |
| 134 | ManglerVector NameBase(1 + Name.length()); |
| 135 | const size_t BufLen = 30 + Name.length() + PrefixLength; |
| 136 | ManglerVector NewName(BufLen); |
| 137 | uint32_t BaseLength = 0; // using uint32_t due to sscanf format string |
| 138 | |
| 139 | int ItemsParsed = sscanf(Name.c_str(), "_ZN%s", NameBase.data()); |
| 140 | if (ItemsParsed == 1) { |
| 141 | // Transform _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz |
| 142 | // (splice in "6Prefix") ^^^^^^^ |
| 143 | snprintf(NewName.data(), BufLen, "_ZN%u%s%s", PrefixLength, |
| 144 | TestPrefix.c_str(), NameBase.data()); |
| 145 | // We ignore the snprintf return value (here and below). If we somehow |
| 146 | // miscalculated the output buffer length, the output will be truncated, |
| 147 | // but it will be truncated consistently for all mangleName() calls on the |
| 148 | // same input string. |
| 149 | incrementSubstitutions(NewName); |
| 150 | return NewName.data(); |
| 151 | } |
| 152 | |
| 153 | // Artificially limit BaseLength to 9 digits (less than 1 billion) because |
| 154 | // sscanf behavior is undefined on integer overflow. If there are more than 9 |
| 155 | // digits (which we test by looking at the beginning of NameBase), then we |
| 156 | // consider this a failure to parse a namespace mangling, and fall back to |
| 157 | // the simple prefixing. |
| 158 | ItemsParsed = sscanf(Name.c_str(), "_Z%9u%s", &BaseLength, NameBase.data()); |
| 159 | if (ItemsParsed == 2 && BaseLength <= strlen(NameBase.data()) && |
| 160 | !isdigit(NameBase[0])) { |
| 161 | // Transform _Z3barxyz ==> _ZN6Prefix3barExyz |
| 162 | // ^^^^^^^^ ^ |
| 163 | // (splice in "N6Prefix", and insert "E" after "3bar") But an "I" after the |
| 164 | // identifier indicates a template argument list terminated with "E"; |
| 165 | // insert the new "E" before/after the old "E". E.g.: |
| 166 | // Transform _Z3barIabcExyz ==> _ZN6Prefix3barIabcEExyz |
| 167 | // ^^^^^^^^ ^ |
| 168 | // (splice in "N6Prefix", and insert "E" after "3barIabcE") |
| 169 | ManglerVector OrigName(Name.length()); |
| 170 | ManglerVector OrigSuffix(Name.length()); |
| 171 | uint32_t ActualBaseLength = BaseLength; |
| 172 | if (NameBase[ActualBaseLength] == 'I') { |
| 173 | ++ActualBaseLength; |
| 174 | while (NameBase[ActualBaseLength] != 'E' && |
| 175 | NameBase[ActualBaseLength] != '\0') |
| 176 | ++ActualBaseLength; |
| 177 | } |
| 178 | strncpy(OrigName.data(), NameBase.data(), ActualBaseLength); |
| 179 | OrigName[ActualBaseLength] = '\0'; |
| 180 | strcpy(OrigSuffix.data(), NameBase.data() + ActualBaseLength); |
| 181 | snprintf(NewName.data(), BufLen, "_ZN%u%s%u%sE%s", PrefixLength, |
| 182 | TestPrefix.c_str(), BaseLength, OrigName.data(), |
| 183 | OrigSuffix.data()); |
| 184 | incrementSubstitutions(NewName); |
| 185 | return NewName.data(); |
| 186 | } |
| 187 | |
| 188 | // Transform bar ==> Prefixbar |
| 189 | // ^^^^^^ |
| 190 | return TestPrefix + Name; |
| 191 | } |
| 192 | |
| 193 | } // end of namespace Ice |