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 22namespace Ice { 23 24using ManglerVector = llvm::SmallVector<char, 32>; 25 26namespace { 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. 38void 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. 120std::string mangleName(const std::string &Name) { 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 129 if (!BuildDefs::dump() || getFlags().getTestPrefix().empty()) 130 return Name; 131 132 const std::string TestPrefix = getFlags().getTestPrefix(); 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 194