[llvm] r339892 - [MS Demangler] Demangle string literals.
Vitaly Buka via llvm-commits
llvm-commits at lists.llvm.org
Thu Aug 16 10:28:22 PDT 2018
I suspect this leak
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fast/builds/22422
is from the patch
On Thu, Aug 16, 2018 at 9:18 AM Zachary Turner via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
> Author: zturner
> Date: Thu Aug 16 09:17:36 2018
> New Revision: 339892
>
> URL: http://llvm.org/viewvc/llvm-project?rev=339892&view=rev
> Log:
> [MS Demangler] Demangle string literals.
>
> When demangling string literals, Microsoft's undname
> simply prints 'string'. This patch implements string
> literal demangling while doing a bit better than this
> by decoding as much of the string as possible and
> trying to faithfully reproduce the original string
> literal definition.
>
> This is a bit tricky because the different character
> types char, char16_t, and char32_t are not uniquely
> identified by the mangling, so we have to use a
> heuristic to try to guess the character type. But
> it works pretty well, and many tests are added to
> illustrate the behavior.
>
> Differential Revision: https://reviews.llvm.org/D50806
>
> Added:
> llvm/trunk/test/Demangle/ms-string-literals.test
> Modified:
> llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp
>
> Modified: llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp?rev=339892&r1=339891&r2=339892&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp (original)
> +++ llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp Thu Aug 16 09:17:36 2018
> @@ -213,7 +213,7 @@ enum NameBackrefBehavior : uint8_t {
> NBB_Simple = 1 << 1, // save simple names.
> };
>
> -enum class SymbolCategory { Function, Variable, Unknown };
> +enum class SymbolCategory { Unknown, Function, Variable, StringLiteral };
>
> namespace {
>
> @@ -291,6 +291,11 @@ struct Name {
> bool IsOperator = false;
> bool IsBackReference = false;
> bool IsConversionOperator = false;
> + bool IsStringLiteral = false;
> + bool IsLongStringLiteral = false;
> +
> + // If IsStringLiteral is true, this is the character type.
> + PrimTy StringLiteralType = PrimTy::None;
>
> // Name read from an MangledName string.
> StringView Str;
> @@ -521,6 +526,30 @@ static void outputParameterList(OutputSt
> }
> }
>
> +static void outputStringLiteral(OutputStream &OS, const Name &TheString) {
> + assert(TheString.IsStringLiteral);
> + switch (TheString.StringLiteralType) {
> + case PrimTy::Wchar:
> + OS << "const wchar_t * {L\"";
> + break;
> + case PrimTy::Char:
> + OS << "const char * {\"";
> + break;
> + case PrimTy::Char16:
> + OS << "const char16_t * {u\"";
> + break;
> + case PrimTy::Char32:
> + OS << "const char32_t * {U\"";
> + break;
> + default:
> + LLVM_BUILTIN_UNREACHABLE;
> + }
> + OS << TheString.Str << "\"";
> + if (TheString.IsLongStringLiteral)
> + OS << "...";
> + OS << "}";
> +}
> +
> static void outputName(OutputStream &OS, const Name *TheName, const Type
> *Ty,
> NameResolver &Resolver);
>
> @@ -1009,6 +1038,7 @@ private:
> Name *demangleSimpleName(StringView &MangledName, bool Memorize);
> Name *demangleAnonymousNamespaceName(StringView &MangledName);
> Name *demangleLocallyScopedNamePiece(StringView &MangledName);
> + Name *demangleStringLiteral(StringView &MangledName);
>
> StringView demangleSimpleString(StringView &MangledName, bool Memorize);
>
> @@ -1017,6 +1047,8 @@ private:
> StorageClass demangleVariableStorageClass(StringView &MangledName);
> ReferenceKind demangleReferenceKind(StringView &MangledName);
> void demangleThrowSpecification(StringView &MangledName);
> + wchar_t demangleWcharLiteral(StringView &MangledName);
> + uint8_t demangleCharLiteral(StringView &MangledName);
>
> std::pair<Qualifiers, bool> demangleQualifiers(StringView &MangledName);
>
> @@ -1056,16 +1088,25 @@ Symbol *Demangler::parse(StringView &Man
> S->Category = SymbolCategory::Unknown;
> S->SymbolName = Arena.alloc<Name>();
> S->SymbolName->Str = MangledName;
> + S->SymbolType = nullptr;
> MangledName = StringView();
> return S;
> }
>
> // MSVC-style mangled symbols must start with '?'.
> if (!MangledName.consumeFront("?")) {
> + S->Category = SymbolCategory::Unknown;
> S->SymbolName = Arena.alloc<Name>();
> S->SymbolName->Str = MangledName;
> - S->SymbolType = Arena.alloc<Type>();
> - S->SymbolType->Prim = PrimTy::Unknown;
> + S->SymbolType = nullptr;
> + return S;
> + }
> +
> + if (MangledName.consumeFront("?_C at _")) {
> + // This is a string literal. Just demangle it and return.
> + S->Category = SymbolCategory::StringLiteral;
> + S->SymbolName = demangleStringLiteral(MangledName);
> + S->SymbolType = nullptr;
> return S;
> }
>
> @@ -1325,6 +1366,32 @@ Name *Demangler::demangleOperatorName(St
> return "|=";
> case '6':
> return "^=";
> + // case '7': # vftable
> + // case '8': # vbtable
> + // case '9': # vcall
> + // case 'A': # typeof
> + // case 'B': # local static guard
> + // case 'D': # vbase destructor
> + // case 'E': # vector deleting destructor
> + // case 'F': # default constructor closure
> + // case 'G': # scalar deleting destructor
> + // case 'H': # vector constructor iterator
> + // case 'I': # vector destructor iterator
> + // case 'J': # vector vbase constructor iterator
> + // case 'K': # virtual displacement map
> + // case 'L': # eh vector constructor iterator
> + // case 'M': # eh vector destructor iterator
> + // case 'N': # eh vector vbase constructor iterator
> + // case 'O': # copy constructor closure
> + // case 'P<name>': # udt returning <name>
> + // case 'Q': # <unknown>
> + // case 'R0': # RTTI Type Descriptor
> + // case 'R1': # RTTI Base Class Descriptor at (a,b,c,d)
> + // case 'R2': # RTTI Base Class Array
> + // case 'R3': # RTTI Class Hierarchy Descriptor
> + // case 'R4': # RTTI Complete Object Locator
> + // case 'S': # local vftable
> + // case 'T': # local vftable constructor closure
> case 'U':
> return " new[]";
> case 'V':
> @@ -1359,6 +1426,9 @@ Name *Demangler::demangleOperatorName(St
> } else {
> Node->Str = NameString();
> }
> + if (Error)
> + return nullptr;
> +
> Node->IsOperator = true;
> return Node;
> }
> @@ -1373,6 +1443,326 @@ Name *Demangler::demangleSimpleName(Stri
> return Node;
> }
>
> +static bool isRebasedHexDigit(char C) { return (C >= 'A' && C <= 'P'); }
> +
> +static uint8_t rebasedHexDigitToNumber(char C) {
> + assert(isRebasedHexDigit(C));
> + return (C <= 'J') ? (C - 'A') : (10 + C - 'K');
> +}
> +
> +uint8_t Demangler::demangleCharLiteral(StringView &MangledName) {
> + if (!MangledName.startsWith('?'))
> + return MangledName.popFront();
> +
> + MangledName = MangledName.dropFront();
> + if (MangledName.empty())
> + goto CharLiteralError;
> +
> + if (MangledName.consumeFront('$')) {
> + // Two hex digits
> + if (MangledName.size() < 2)
> + goto CharLiteralError;
> + StringView Nibbles = MangledName.substr(0, 2);
> + if (!isRebasedHexDigit(Nibbles[0]) || !isRebasedHexDigit(Nibbles[1]))
> + goto CharLiteralError;
> + // Don't append the null terminator.
> + uint8_t C1 = rebasedHexDigitToNumber(Nibbles[0]);
> + uint8_t C2 = rebasedHexDigitToNumber(Nibbles[1]);
> + MangledName = MangledName.dropFront(2);
> + return (C1 << 4) | C2;
> + }
> +
> + if (startsWithDigit(MangledName)) {
> + const char *Lookup = ",/\\:. \n\t'-";
> + char C = Lookup[MangledName[0] - '0'];
> + MangledName = MangledName.dropFront();
> + return C;
> + }
> +
> + if (MangledName[0] >= 'a' && MangledName[0] <= 'z') {
> + char Lookup[26] = {'\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6',
> '\xE7',
> + '\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED',
> '\xEE',
> + '\xEF', '\xF0', '\xF1', '\xF2', '\xF3', '\xF4',
> '\xF5',
> + '\xF6', '\xF7', '\xF8', '\xF9', '\xFA'};
> + char C = Lookup[MangledName[0] - 'a'];
> + MangledName = MangledName.dropFront();
> + return C;
> + }
> +
> + if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') {
> + char Lookup[26] = {'\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6',
> '\xC7',
> + '\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD',
> '\xCE',
> + '\xCF', '\xD0', '\xD1', '\xD2', '\xD3', '\xD4',
> '\xD5',
> + '\xD6', '\xD7', '\xD8', '\xD9', '\xDA'};
> + char C = Lookup[MangledName[0] - 'A'];
> + MangledName = MangledName.dropFront();
> + return C;
> + }
> +
> +CharLiteralError:
> + Error = true;
> + return '\0';
> +}
> +
> +wchar_t Demangler::demangleWcharLiteral(StringView &MangledName) {
> + uint8_t C1 = demangleCharLiteral(MangledName);
> + if (Error)
> + goto WCharLiteralError;
> + uint8_t C2 = demangleCharLiteral(MangledName);
> + if (Error)
> + goto WCharLiteralError;
> +
> + return ((wchar_t)C1 << 8) | (wchar_t)C2;
> +
> +WCharLiteralError:
> + Error = true;
> + return L'\0';
> +}
> +
> +static void writeHexDigit(char *Buffer, uint8_t Digit) {
> + assert(Digit <= 15);
> + *Buffer = (Digit < 10) ? ('0' + Digit) : ('A' + Digit - 10);
> +}
> +
> +static void outputHex(OutputStream &OS, unsigned C) {
> + if (C == 0) {
> + OS << "\\x00";
> + return;
> + }
> + // It's easier to do the math if we can work from right to left, but we
> need
> + // to print the numbers from left to right. So render this into a
> temporary
> + // buffer first, then output the temporary buffer. Each byte is of the
> form
> + // \xAB, which means that each byte needs 4 characters. Since there
> are at
> + // most 4 bytes, we need a 4*4+1 = 17 character temporary buffer.
> + char TempBuffer[17];
> +
> + ::memset(TempBuffer, 0, sizeof(TempBuffer));
> + constexpr int MaxPos = 15;
> +
> + int Pos = MaxPos - 1;
> + while (C != 0) {
> + for (int I = 0; I < 2; ++I) {
> + writeHexDigit(&TempBuffer[Pos--], C % 16);
> + C /= 16;
> + }
> + TempBuffer[Pos--] = 'x';
> + TempBuffer[Pos--] = '\\';
> + assert(Pos >= 0);
> + }
> + OS << StringView(&TempBuffer[Pos + 1]);
> +}
> +
> +static void outputEscapedChar(OutputStream &OS, unsigned C) {
> + switch (C) {
> + case '\'': // single quote
> + OS << "\\\'";
> + return;
> + case '\"': // double quote
> + OS << "\\\"";
> + return;
> + case '\\': // backslash
> + OS << "\\\\";
> + return;
> + case '\a': // bell
> + OS << "\\a";
> + return;
> + case '\b': // backspace
> + OS << "\\b";
> + return;
> + case '\f': // form feed
> + OS << "\\f";
> + return;
> + case '\n': // new line
> + OS << "\\n";
> + return;
> + case '\r': // carriage return
> + OS << "\\r";
> + return;
> + case '\t': // tab
> + OS << "\\t";
> + return;
> + case '\v': // vertical tab
> + OS << "\\v";
> + return;
> + default:
> + break;
> + }
> +
> + if (C > 0x1F && C < 0x7F) {
> + // Standard ascii char.
> + OS << (char)C;
> + return;
> + }
> +
> + outputHex(OS, C);
> +}
> +
> +unsigned countTrailingNullBytes(const uint8_t *StringBytes, int Length) {
> + const uint8_t *End = StringBytes + Length - 1;
> + while (Length > 0 && *End == 0) {
> + --Length;
> + --End;
> + }
> + return End - StringBytes + 1;
> +}
> +
> +unsigned countEmbeddedNulls(const uint8_t *StringBytes, unsigned Length) {
> + unsigned Result = 0;
> + for (unsigned I = 0; I < Length; ++I) {
> + if (*StringBytes++ == 0)
> + ++Result;
> + }
> + return Result;
> +}
> +
> +unsigned guessCharByteSize(const uint8_t *StringBytes, unsigned NumChars,
> + unsigned NumBytes) {
> + assert(NumBytes > 0);
> +
> + // If the number of bytes is odd, this is guaranteed to be a char
> string.
> + if (NumBytes % 2 == 1)
> + return 1;
> +
> + // All strings can encode at most 32 bytes of data. If it's less than
> that,
> + // then we encoded the entire string. In this case we check for a
> 1-byte,
> + // 2-byte, or 4-byte null terminator.
> + if (NumBytes < 32) {
> + unsigned TrailingNulls = countTrailingNullBytes(StringBytes,
> NumChars);
> + if (TrailingNulls >= 4)
> + return 4;
> + if (TrailingNulls >= 2)
> + return 2;
> + return 1;
> + }
> +
> + // The whole string was not able to be encoded. Try to look at
> embedded null
> + // terminators to guess. The heuristic is that we count all embedded
> null
> + // terminators. If more than 2/3 are null, it's a char32. If more
> than 1/3
> + // are null, it's a char16. Otherwise it's a char8. This obviously
> isn't
> + // perfect and is biased towards languages that have ascii alphabets,
> but this
> + // was always going to be best effort since the encoding is lossy.
> + unsigned Nulls = countEmbeddedNulls(StringBytes, NumChars);
> + if (Nulls >= 2 * NumChars / 3)
> + return 4;
> + if (Nulls >= NumChars / 3)
> + return 2;
> + return 1;
> +}
> +
> +static unsigned decodeMultiByteChar(const uint8_t *StringBytes,
> + unsigned CharIndex, unsigned
> CharBytes) {
> + assert(CharBytes == 1 || CharBytes == 2 || CharBytes == 4);
> + unsigned Offset = CharIndex * CharBytes;
> + unsigned Result = 0;
> + StringBytes = StringBytes + Offset;
> + for (unsigned I = 0; I < CharBytes; ++I) {
> + unsigned C = static_cast<unsigned>(StringBytes[I]);
> + Result |= C << (8 * I);
> + }
> + return Result;
> +}
> +
> +Name *Demangler::demangleStringLiteral(StringView &MangledName) {
> + OutputStream OS;
> + StringView CRC;
> + Name *Result = Arena.alloc<Name>();
> + Result->IsStringLiteral = true;
> +
> + // Prefix indicating the beginning of a string literal
> + if (MangledName.empty())
> + goto StringLiteralError;
> +
> + // Char Type (regular or wchar_t)
> + bool IsWcharT = false;
> + switch (MangledName.popFront()) {
> + case '1':
> + IsWcharT = true;
> + LLVM_FALLTHROUGH;
> + case '0':
> + break;
> + default:
> + goto StringLiteralError;
> + }
> +
> + // Encoded Length
> + uint64_t StringByteSize;
> + bool IsNegative;
> + std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName);
> + if (Error || IsNegative)
> + goto StringLiteralError;
> +
> + // CRC 32 (always 8 characters plus a terminator)
> + size_t CrcEndPos = MangledName.find('@');
> + if (CrcEndPos == StringView::npos)
> + goto StringLiteralError;
> + CRC = MangledName.substr(0, CrcEndPos);
> + MangledName = MangledName.dropFront(CrcEndPos + 1);
> + if (MangledName.empty())
> + goto StringLiteralError;
> +
> + OS = OutputStream::create(nullptr, nullptr, 1024);
> + if (IsWcharT) {
> + Result->StringLiteralType = PrimTy::Wchar;
> + if (StringByteSize > 64)
> + Result->IsLongStringLiteral = true;
> +
> + while (!MangledName.consumeFront('@')) {
> + assert(StringByteSize >= 2);
> + wchar_t W = demangleWcharLiteral(MangledName);
> + if (StringByteSize != 2 || Result->IsLongStringLiteral)
> + outputEscapedChar(OS, W);
> + StringByteSize -= 2;
> + if (Error)
> + goto StringLiteralError;
> + }
> + } else {
> + if (StringByteSize > 32)
> + Result->IsLongStringLiteral = true;
> +
> + constexpr unsigned MaxStringByteLength = 32;
> + uint8_t StringBytes[MaxStringByteLength];
> +
> + unsigned BytesDecoded = 0;
> + while (!MangledName.consumeFront('@')) {
> + assert(StringByteSize >= 1);
> + StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName);
> + }
> +
> + unsigned CharBytes =
> + guessCharByteSize(StringBytes, BytesDecoded, StringByteSize);
> + assert(StringByteSize % CharBytes == 0);
> + switch (CharBytes) {
> + case 1:
> + Result->StringLiteralType = PrimTy::Char;
> + break;
> + case 2:
> + Result->StringLiteralType = PrimTy::Char16;
> + break;
> + case 4:
> + Result->StringLiteralType = PrimTy::Char32;
> + break;
> + default:
> + LLVM_BUILTIN_UNREACHABLE;
> + }
> + const unsigned NumChars = BytesDecoded / CharBytes;
> + for (unsigned CharIndex = 0; CharIndex < NumChars; ++CharIndex) {
> + unsigned NextChar =
> + decodeMultiByteChar(StringBytes, CharIndex, CharBytes);
> + if (CharIndex + 1 < NumChars || Result->IsLongStringLiteral)
> + outputEscapedChar(OS, NextChar);
> + }
> + }
> +
> + OS << '\0';
> + char *ResultBuffer = OS.getBuffer();
> + Result->Str = copyString(ResultBuffer);
> + return Result;
> +
> +StringLiteralError:
> + Error = true;
> + return nullptr;
> +}
> +
> StringView Demangler::demangleSimpleString(StringView &MangledName,
> bool Memorize) {
> StringView S;
> @@ -2193,6 +2583,11 @@ void Demangler::output(const Symbol *S,
> outputName(OS, S->SymbolName, S->SymbolType, *this);
> return;
> }
> + if (S->Category == SymbolCategory::StringLiteral) {
> + outputStringLiteral(OS, *S->SymbolName);
> + return;
> + }
> +
> // Converts an AST to a string.
> //
> // Converting an AST representing a C++ type to a string is tricky due
>
> Added: llvm/trunk/test/Demangle/ms-string-literals.test
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Demangle/ms-string-literals.test?rev=339892&view=auto
>
> ==============================================================================
> --- llvm/trunk/test/Demangle/ms-string-literals.test (added)
> +++ llvm/trunk/test/Demangle/ms-string-literals.test Thu Aug 16 09:17:36
> 2018
> @@ -0,0 +1,758 @@
> +; RUN: llvm-undname < %s | FileCheck %s
> +
> +; CHECK-NOT: Invalid mangled name
> +
> +??_C at _01CNACBAHC@?$PP?$AA@
> +??_C at _01DEBJCBDD@?$PO?$AA@
> +??_C at _01BPDEHCPA@?$PN?$AA@
> +??_C at _01GCPEDLB@?$PM?$AA@
> +??_C at _01EJGONFHG@?$PL?$AA@
> +??_C at _01FAHFOEDH@?z?$AA@
> +??_C at _01HLFILHPE@?y?$AA@
> +??_C at _01GCEDIGLF@?x?$AA@
> +??_C at _01OFNLJKHK@?w?$AA@
> +??_C at _01PMMAKLDL@?v?$AA@
> +??_C at _01NHONPIPI@?u?$AA@
> +??_C at _01MOPGMJLJ@?t?$AA@
> +??_C at _01IBLHFPHO@?s?$AA@
> +??_C at _01JIKMGODP@?r?$AA@
> +??_C at _01LDIBDNPM@?q?$AA@
> +??_C at _01KKJKAMLN@?p?$AA@
> +??_C at _01GHMAACCD@?o?$AA@
> +??_C at _01HONLDDGC@?n?$AA@
> +??_C at _01FFPGGAKB@?m?$AA@
> +??_C at _01EMONFBOA@?l?$AA@
> +??_C at _01DKMMHCH@?k?$AA@
> +??_C at _01BKLHPGGG@?j?$AA@
> +??_C at _01DBJKKFKF@?i?$AA@
> +??_C at _01CIIBJEOE@?h?$AA@
> +??_C at _01KPBJIICL@?g?$AA@
> +??_C at _01LGACLJGK@?f?$AA@
> +??_C at _01JNCPOKKJ@?e?$AA@
> +??_C at _01IEDENLOI@?d?$AA@
> +??_C at _01MLHFENCP@?c?$AA@
> +??_C at _01NCGOHMGO@?b?$AA@
> +??_C at _01PJEDCPKN@?a?$AA@
> +??_C at _01OAFIBOOM@?$OA?$AA@
> +??_C at _01LIIGDENA@?$NP?$AA@
> +??_C at _01KBJNAFJB@?$NO?$AA@
> +??_C at _01IKLAFGFC@?$NN?$AA@
> +??_C at _01JDKLGHBD@?$NM?$AA@
> +??_C at _01NMOKPBNE@?$NL?$AA@
> +??_C at _01MFPBMAJF@?Z?$AA@
> +??_C at _01OONMJDFG@?Y?$AA@
> +??_C at _01PHMHKCBH@?X?$AA@
> +??_C at _01HAFPLONI@?W?$AA@
> +??_C at _01GJEEIPJJ@?V?$AA@
> +??_C at _01ECGJNMFK@?U?$AA@
> +??_C at _01FLHCONBL@?T?$AA@
> +??_C at _01BEDDHLNM@?S?$AA@
> +??_C at _01NCIEKJN@?R?$AA@
> +??_C at _01CGAFBJFO@?Q?$AA@
> +??_C at _01DPBOCIBP@?P?$AA@
> +??_C at _01PCEECGIB@?O?$AA@
> +??_C at _01OLFPBHMA@?N?$AA@
> +??_C at _01MAHCEEAD@?M?$AA@
> +??_C at _01NJGJHFEC@?L?$AA@
> +??_C at _01JGCIODIF@?K?$AA@
> +??_C at _01IPDDNCME@?J?$AA@
> +??_C at _01KEBOIBAH@?I?$AA@
> +??_C at _01LNAFLAEG@?H?$AA@
> +??_C at _01DKJNKMIJ@?G?$AA@
> +??_C at _01CDIGJNMI@?F?$AA@
> +??_C at _01IKLMOAL@?E?$AA@
> +??_C at _01BBLAPPEK@?D?$AA@
> +??_C at _01FOPBGJIN@?C?$AA@
> +??_C at _01EHOKFIMM@?B?$AA@
> +??_C at _01GMMHALAP@?A?$AA@
> +??_C at _01HFNMDKEO@?$MA?$AA@
> +??_C at _01NNHLFPHH@?$LP?$AA@
> +??_C at _01MEGAGODG@?$LO?$AA@
> +??_C at _01OPENDNPF@?$LN?$AA@
> +??_C at _01PGFGAMLE@?$LM?$AA@
> +??_C at _01LJBHJKHD@?$LL?$AA@
> +??_C at _01KAAMKLDC@?$LK?$AA@
> +??_C at _01ILCBPIPB@?$LJ?$AA@
> +??_C at _01JCDKMJLA@?$LI?$AA@
> +??_C at _01BFKCNFHP@?$LH?$AA@
> +??_C at _01MLJOEDO@?$LG?$AA@
> +??_C at _01CHJELHPN@?$LF?$AA@
> +??_C at _01DOIPIGLM@?$LE?$AA@
> +??_C at _01HBMOBAHL@?$LD?$AA@
> +??_C at _01GINFCBDK@?$LC?$AA@
> +??_C at _01EDPIHCPJ@?$LB?$AA@
> +??_C at _01FKODEDLI@?$LA?$AA@
> +??_C at _01JHLJENCG@?$KP?$AA@
> +??_C at _01IOKCHMGH@?$KO?$AA@
> +??_C at _01KFIPCPKE@?$KN?$AA@
> +??_C at _01LMJEBOOF@?$KM?$AA@
> +??_C at _01PDNFIICC@?$KL?$AA@
> +??_C at _01OKMOLJGD@?$KK?$AA@
> +??_C at _01MBODOKKA@?$KJ?$AA@
> +??_C at _01NIPINLOB@?$KI?$AA@
> +??_C at _01FPGAMHCO@?$KH?$AA@
> +??_C at _01EGHLPGGP@?$KG?$AA@
> +??_C at _01GNFGKFKM@?$KF?$AA@
> +??_C at _01HEENJEON@?$KE?$AA@
> +??_C at _01DLAMACCK@?$KD?$AA@
> +??_C at _01CCBHDDGL@?$KC?$AA@
> +??_C at _01JDKGAKI@?$KB?$AA@
> +??_C at _01BACBFBOJ@?$KA?$AA@
> +??_C at _01EIPPHLNF@?$JP?$AA@
> +??_C at _01FBOEEKJE@?$JO?$AA@
> +??_C at _01HKMJBJFH@?$JN?$AA@
> +??_C at _01GDNCCIBG@?$JM?$AA@
> +??_C at _01CMJDLONB@?$JL?$AA@
> +??_C at _01DFIIIPJA@?$JK?$AA@
> +??_C at _01BOKFNMFD@?$JJ?$AA@
> +??_C at _01HLOONBC@?$JI?$AA@
> +??_C at _01IACGPBNN@?$JH?$AA@
> +??_C at _01JJDNMAJM@?$JG?$AA@
> +??_C at _01LCBAJDFP@?$JF?$AA@
> +??_C at _01KLALKCBO@?$JE?$AA@
> +??_C at _01OEEKDENJ@?$JD?$AA@
> +??_C at _01PNFBAFJI@?$JC?$AA@
> +??_C at _01NGHMFGFL@?$JB?$AA@
> +??_C at _01MPGHGHBK@?$JA?$AA@
> +??_C at _01CDNGJIE@?$IP?$AA@
> +??_C at _01BLCGFIMF@?$IO?$AA@
> +??_C at _01DAALALAG@?$IN?$AA@
> +??_C at _01CJBADKEH@?$IM?$AA@
> +??_C at _01GGFBKMIA@?$IL?$AA@
> +??_C at _01HPEKJNMB@?$IK?$AA@
> +??_C at _01FEGHMOAC@?$IJ?$AA@
> +??_C at _01ENHMPPED@?$II?$AA@
> +??_C at _01MKOEODIM@?$IH?$AA@
> +??_C at _01NDPPNCMN@?$IG?$AA@
> +??_C at _01PINCIBAO@?$IF?$AA@
> +??_C at _01OBMJLAEP@?$IE?$AA@
> +??_C at _01KOIICGII@?$ID?$AA@
> +??_C at _01LHJDBHMJ@?$IC?$AA@
> +??_C at _01JMLOEEAK@?$IB?$AA@
> +??_C at _01IFKFHFEL@?$IA?$AA@
> +??_C at _01BGIBIIDJ@?$HP?$AA@
> +??_C at _01PJKLJHI@?$HO?$AA@
> +??_C at _01CELHOKLL@?$HN?$AA@
> +??_C at _01DNKMNLPK@?$HM?$AA@
> +??_C at _01HCONENDN@?$HL?$AA@
> +??_C at _01GLPGHMHM@z?$AA@
> +??_C at _01EANLCPLP@y?$AA@
> +??_C at _01FJMABOPO@x?$AA@
> +??_C at _01NOFIACDB@w?$AA@
> +??_C at _01MHEDDDHA@v?$AA@
> +??_C at _01OMGOGALD@u?$AA@
> +??_C at _01PFHFFBPC@t?$AA@
> +??_C at _01LKDEMHDF@s?$AA@
> +??_C at _01KDCPPGHE@r?$AA@
> +??_C at _01IIACKFLH@q?$AA@
> +??_C at _01JBBJJEPG@p?$AA@
> +??_C at _01FMEDJKGI@o?$AA@
> +??_C at _01EFFIKLCJ@n?$AA@
> +??_C at _01GOHFPIOK@m?$AA@
> +??_C at _01HHGOMJKL@l?$AA@
> +??_C at _01DICPFPGM@k?$AA@
> +??_C at _01CBDEGOCN@j?$AA@
> +??_C at _01KBJDNOO@i?$AA@
> +??_C at _01BDACAMKP@h?$AA@
> +??_C at _01JEJKBAGA@g?$AA@
> +??_C at _01INIBCBCB@f?$AA@
> +??_C at _01KGKMHCOC@e?$AA@
> +??_C at _01LPLHEDKD@d?$AA@
> +??_C at _01PAPGNFGE@c?$AA@
> +??_C at _01OJONOECF@b?$AA@
> +??_C at _01MCMALHOG@a?$AA@
> +??_C at _01NLNLIGKH@?$GA?$AA@
> +??_C at _01IDAFKMJL@_?$AA@
> +??_C at _01JKBOJNNK@?$FO?$AA@
> +??_C at _01LBDDMOBJ@?$FN?$AA@
> +??_C at _01KICIPPFI@?2?$AA@
> +??_C at _01OHGJGJJP@?$FL?$AA@
> +??_C at _01POHCFINO@Z?$AA@
> +??_C at _01NFFPALBN@Y?$AA@
> +??_C at _01MMEEDKFM@X?$AA@
> +??_C at _01ELNMCGJD@W?$AA@
> +??_C at _01FCMHBHNC@V?$AA@
> +??_C at _01HJOKEEBB@U?$AA@
> +??_C at _01GAPBHFFA@T?$AA@
> +??_C at _01CPLAODJH@S?$AA@
> +??_C at _01DGKLNCNG@R?$AA@
> +??_C at _01BNIGIBBF@Q?$AA@
> +??_C at _01EJNLAFE@P?$AA@
> +??_C at _01MJMHLOMK@O?$AA@
> +??_C at _01NANMIPIL@N?$AA@
> +??_C at _01PLPBNMEI@M?$AA@
> +??_C at _01OCOKONAJ@L?$AA@
> +??_C at _01KNKLHLMO@K?$AA@
> +??_C at _01LELAEKIP@J?$AA@
> +??_C at _01JPJNBJEM@I?$AA@
> +??_C at _01IGIGCIAN@H?$AA@
> +??_C at _01BBODEMC@G?$AA@
> +??_C at _01BIAFAFID@F?$AA@
> +??_C at _01DDCIFGEA@E?$AA@
> +??_C at _01CKDDGHAB@D?$AA@
> +??_C at _01GFHCPBMG@C?$AA@
> +??_C at _01HMGJMAIH@B?$AA@
> +??_C at _01FHEEJDEE@A?$AA@
> +??_C at _01EOFPKCAF@?$EA?$AA@
> +??_C at _01OGPIMHDM@?$DP?$AA@
> +??_C at _01PPODPGHN@?$DO?$AA@
> +??_C at _01NEMOKFLO@?$DN?$AA@
> +??_C at _01MNNFJEPP@?$DM?$AA@
> +??_C at _01ICJEACDI@?$DL?$AA@
> +??_C at _01JLIPDDHJ@?3?$AA@
> +??_C at _01LAKCGALK@9?$AA@
> +??_C at _01KJLJFBPL@8?$AA@
> +??_C at _01COCBENDE@7?$AA@
> +??_C at _01DHDKHMHF@6?$AA@
> +??_C at _01BMBHCPLG@5?$AA@
> +??_C at _01FAMBOPH@4?$AA@
> +??_C at _01EKENIIDA@3?$AA@
> +??_C at _01FDFGLJHB@2?$AA@
> +??_C at _01HIHLOKLC@1?$AA@
> +??_C at _01GBGANLPD@0?$AA@
> +??_C at _01KMDKNFGN@?1?$AA@
> +??_C at _01LFCBOECM@?4?$AA@
> +??_C at _01JOAMLHOP@?9?$AA@
> +??_C at _01IHBHIGKO@?0?$AA@
> +??_C at _01MIFGBAGJ@?$CL?$AA@
> +??_C at _01NBENCBCI@?$CK?$AA@
> +??_C at _01PKGAHCOL@?$CJ?$AA@
> +??_C at _01ODHLEDKK@?$CI?$AA@
> +??_C at _01GEODFPGF@?8?$AA@
> +??_C at _01HNPIGOCE@?$CG?$AA@
> +??_C at _01FGNFDNOH@?$CF?$AA@
> +??_C at _01EPMOAMKG@$?$AA@
> +??_C at _01IPJKGB@?$CD?$AA@
> +??_C at _01BJJEKLCA@?$CC?$AA@
> +??_C at _01DCLJPIOD@?$CB?$AA@
> +??_C at _01CLKCMJKC@?5?$AA@
> +??_C at _01HDHMODJO@?$BP?$AA@
> +??_C at _01GKGHNCNP@?$BO?$AA@
> +??_C at _01EBEKIBBM@?$BN?$AA@
> +??_C at _01FIFBLAFN@?$BM?$AA@
> +??_C at _01BHBACGJK@?$BL?$AA@
> +??_C at _01OALBHNL@?$BK?$AA@
> +??_C at _01CFCGEEBI@?$BJ?$AA@
> +??_C at _01DMDNHFFJ@?$BI?$AA@
> +??_C at _01LLKFGJJG@?$BH?$AA@
> +??_C at _01KCLOFINH@?$BG?$AA@
> +??_C at _01IJJDALBE@?$BF?$AA@
> +??_C at _01JAIIDKFF@?$BE?$AA@
> +??_C at _01NPMJKMJC@?$BD?$AA@
> +??_C at _01MGNCJNND@?$BC?$AA@
> +??_C at _01ONPPMOBA@?$BB?$AA@
> +??_C at _01PEOEPPFB@?$BA?$AA@
> +??_C at _01DJLOPBMP@?$AP?$AA@
> +??_C at _01CAKFMAIO@?$AO?$AA@
> +??_C at _01LIIJDEN@?$AN?$AA@
> +??_C at _01BCJDKCAM@?$AM?$AA@
> +??_C at _01FNNCDEML@?$AL?$AA@
> +??_C at _01EEMJAFIK@?6?$AA@
> +??_C at _01GPOEFGEJ@?7?$AA@
> +??_C at _01HGPPGHAI@?$AI?$AA@
> +??_C at _01PBGHHLMH@?$AH?$AA@
> +??_C at _01OIHMEKIG@?$AG?$AA@
> +??_C at _01MDFBBJEF@?$AF?$AA@
> +??_C at _01NKEKCIAE@?$AE?$AA@
> +??_C at _01JFALLOMD@?$AD?$AA@
> +??_C at _01IMBAIPIC@?$AC?$AA@
> +??_C at _01KHDNNMEB@?$AB?$AA@
> +??_C at _01LOCGONAA@?$AA?$AA@
> +
> +; CHECK: const char * {"\xFF"}
> +; CHECK: const char * {"\xFE"}
> +; CHECK: const char * {"\xFD"}
> +; CHECK: const char * {"\xFC"}
> +; CHECK: const char * {"\xFB"}
> +; CHECK: const char * {"\xFA"}
> +; CHECK: const char * {"\xF9"}
> +; CHECK: const char * {"\xF8"}
> +; CHECK: const char * {"\xF7"}
> +; CHECK: const char * {"\xF6"}
> +; CHECK: const char * {"\xF5"}
> +; CHECK: const char * {"\xF4"}
> +; CHECK: const char * {"\xF3"}
> +; CHECK: const char * {"\xF2"}
> +; CHECK: const char * {"\xF1"}
> +; CHECK: const char * {"\xF0"}
> +; CHECK: const char * {"\xEF"}
> +; CHECK: const char * {"\xEE"}
> +; CHECK: const char * {"\xED"}
> +; CHECK: const char * {"\xEC"}
> +; CHECK: const char * {"\xEB"}
> +; CHECK: const char * {"\xEA"}
> +; CHECK: const char * {"\xE9"}
> +; CHECK: const char * {"\xE8"}
> +; CHECK: const char * {"\xE7"}
> +; CHECK: const char * {"\xE6"}
> +; CHECK: const char * {"\xE5"}
> +; CHECK: const char * {"\xE4"}
> +; CHECK: const char * {"\xE3"}
> +; CHECK: const char * {"\xE2"}
> +; CHECK: const char * {"\xE1"}
> +; CHECK: const char * {"\xE0"}
> +; CHECK: const char * {"\xDF"}
> +; CHECK: const char * {"\xDE"}
> +; CHECK: const char * {"\xDD"}
> +; CHECK: const char * {"\xDC"}
> +; CHECK: const char * {"\xDB"}
> +; CHECK: const char * {"\xDA"}
> +; CHECK: const char * {"\xD9"}
> +; CHECK: const char * {"\xD8"}
> +; CHECK: const char * {"\xD7"}
> +; CHECK: const char * {"\xD6"}
> +; CHECK: const char * {"\xD5"}
> +; CHECK: const char * {"\xD4"}
> +; CHECK: const char * {"\xD3"}
> +; CHECK: const char * {"\xD2"}
> +; CHECK: const char * {"\xD1"}
> +; CHECK: const char * {"\xD0"}
> +; CHECK: const char * {"\xCF"}
> +; CHECK: const char * {"\xCE"}
> +; CHECK: const char * {"\xCD"}
> +; CHECK: const char * {"\xCC"}
> +; CHECK: const char * {"\xCB"}
> +; CHECK: const char * {"\xCA"}
> +; CHECK: const char * {"\xC9"}
> +; CHECK: const char * {"\xC8"}
> +; CHECK: const char * {"\xC7"}
> +; CHECK: const char * {"\xC6"}
> +; CHECK: const char * {"\xC5"}
> +; CHECK: const char * {"\xC4"}
> +; CHECK: const char * {"\xC3"}
> +; CHECK: const char * {"\xC2"}
> +; CHECK: const char * {"\xC1"}
> +; CHECK: const char * {"\xC0"}
> +; CHECK: const char * {"\xBF"}
> +; CHECK: const char * {"\xBE"}
> +; CHECK: const char * {"\xBD"}
> +; CHECK: const char * {"\xBC"}
> +; CHECK: const char * {"\xBB"}
> +; CHECK: const char * {"\xBA"}
> +; CHECK: const char * {"\xB9"}
> +; CHECK: const char * {"\xB8"}
> +; CHECK: const char * {"\xB7"}
> +; CHECK: const char * {"\xB6"}
> +; CHECK: const char * {"\xB5"}
> +; CHECK: const char * {"\xB4"}
> +; CHECK: const char * {"\xB3"}
> +; CHECK: const char * {"\xB2"}
> +; CHECK: const char * {"\xB1"}
> +; CHECK: const char * {"\xB0"}
> +; CHECK: const char * {"\xAF"}
> +; CHECK: const char * {"\xAE"}
> +; CHECK: const char * {"\xAD"}
> +; CHECK: const char * {"\xAC"}
> +; CHECK: const char * {"\xAB"}
> +; CHECK: const char * {"\xAA"}
> +; CHECK: const char * {"\xA9"}
> +; CHECK: const char * {"\xA8"}
> +; CHECK: const char * {"\xA7"}
> +; CHECK: const char * {"\xA6"}
> +; CHECK: const char * {"\xA5"}
> +; CHECK: const char * {"\xA4"}
> +; CHECK: const char * {"\xA3"}
> +; CHECK: const char * {"\xA2"}
> +; CHECK: const char * {"\xA1"}
> +; CHECK: const char * {"\xA0"}
> +; CHECK: const char * {"\x9F"}
> +; CHECK: const char * {"\x9E"}
> +; CHECK: const char * {"\x9D"}
> +; CHECK: const char * {"\x9C"}
> +; CHECK: const char * {"\x9B"}
> +; CHECK: const char * {"\x9A"}
> +; CHECK: const char * {"\x99"}
> +; CHECK: const char * {"\x98"}
> +; CHECK: const char * {"\x97"}
> +; CHECK: const char * {"\x96"}
> +; CHECK: const char * {"\x95"}
> +; CHECK: const char * {"\x94"}
> +; CHECK: const char * {"\x93"}
> +; CHECK: const char * {"\x92"}
> +; CHECK: const char * {"\x91"}
> +; CHECK: const char * {"\x90"}
> +; CHECK: const char * {"\x8F"}
> +; CHECK: const char * {"\x8E"}
> +; CHECK: const char * {"\x8D"}
> +; CHECK: const char * {"\x8C"}
> +; CHECK: const char * {"\x8B"}
> +; CHECK: const char * {"\x8A"}
> +; CHECK: const char * {"\x89"}
> +; CHECK: const char * {"\x88"}
> +; CHECK: const char * {"\x87"}
> +; CHECK: const char * {"\x86"}
> +; CHECK: const char * {"\x85"}
> +; CHECK: const char * {"\x84"}
> +; CHECK: const char * {"\x83"}
> +; CHECK: const char * {"\x82"}
> +; CHECK: const char * {"\x81"}
> +; CHECK: const char * {"\x80"}
> +; CHECK: const char * {"\x7F"}
> +; CHECK: const char * {"~"}
> +; CHECK: const char * {"}"}
> +; CHECK: const char * {"|"}
> +; CHECK: const char * {"{"}
> +; CHECK: const char * {"z"}
> +; CHECK: const char * {"y"}
> +; CHECK: const char * {"x"}
> +; CHECK: const char * {"w"}
> +; CHECK: const char * {"v"}
> +; CHECK: const char * {"u"}
> +; CHECK: const char * {"t"}
> +; CHECK: const char * {"s"}
> +; CHECK: const char * {"r"}
> +; CHECK: const char * {"q"}
> +; CHECK: const char * {"p"}
> +; CHECK: const char * {"o"}
> +; CHECK: const char * {"n"}
> +; CHECK: const char * {"m"}
> +; CHECK: const char * {"l"}
> +; CHECK: const char * {"k"}
> +; CHECK: const char * {"j"}
> +; CHECK: const char * {"i"}
> +; CHECK: const char * {"h"}
> +; CHECK: const char * {"g"}
> +; CHECK: const char * {"f"}
> +; CHECK: const char * {"e"}
> +; CHECK: const char * {"d"}
> +; CHECK: const char * {"c"}
> +; CHECK: const char * {"b"}
> +; CHECK: const char * {"a"}
> +; CHECK: const char * {"`"}
> +; CHECK: const char * {"_"}
> +; CHECK: const char * {"^"}
> +; CHECK: const char * {"]"}
> +; CHECK: const char * {"\\"}
> +; CHECK: const char * {"["}
> +; CHECK: const char * {"Z"}
> +; CHECK: const char * {"Y"}
> +; CHECK: const char * {"X"}
> +; CHECK: const char * {"W"}
> +; CHECK: const char * {"V"}
> +; CHECK: const char * {"U"}
> +; CHECK: const char * {"T"}
> +; CHECK: const char * {"S"}
> +; CHECK: const char * {"R"}
> +; CHECK: const char * {"Q"}
> +; CHECK: const char * {"P"}
> +; CHECK: const char * {"O"}
> +; CHECK: const char * {"N"}
> +; CHECK: const char * {"M"}
> +; CHECK: const char * {"L"}
> +; CHECK: const char * {"K"}
> +; CHECK: const char * {"J"}
> +; CHECK: const char * {"I"}
> +; CHECK: const char * {"H"}
> +; CHECK: const char * {"G"}
> +; CHECK: const char * {"F"}
> +; CHECK: const char * {"E"}
> +; CHECK: const char * {"D"}
> +; CHECK: const char * {"C"}
> +; CHECK: const char * {"B"}
> +; CHECK: const char * {"A"}
> +; CHECK: const char * {"@"}
> +; CHECK: const char * {"?"}
> +; CHECK: const char * {">"}
> +; CHECK: const char * {"="}
> +; CHECK: const char * {"<"}
> +; CHECK: const char * {";"}
> +; CHECK: const char * {":"}
> +; CHECK: const char * {"9"}
> +; CHECK: const char * {"8"}
> +; CHECK: const char * {"7"}
> +; CHECK: const char * {"6"}
> +; CHECK: const char * {"5"}
> +; CHECK: const char * {"4"}
> +; CHECK: const char * {"3"}
> +; CHECK: const char * {"2"}
> +; CHECK: const char * {"1"}
> +; CHECK: const char * {"0"}
> +; CHECK: const char * {"/"}
> +; CHECK: const char * {"."}
> +; CHECK: const char * {"-"}
> +; CHECK: const char * {","}
> +; CHECK: const char * {"+"}
> +; CHECK: const char * {"*"}
> +; CHECK: const char * {")"}
> +; CHECK: const char * {"("}
> +; CHECK: const char * {"\'"}
> +; CHECK: const char * {"&"}
> +; CHECK: const char * {"%"}
> +; CHECK: const char * {"$"}
> +; CHECK: const char * {"#"}
> +; CHECK: const char * {"\""}
> +; CHECK: const char * {"!"}
> +; CHECK: const char * {" "}
> +; CHECK: const char * {"\x1F"}
> +; CHECK: const char * {"\x1E"}
> +; CHECK: const char * {"\x1D"}
> +; CHECK: const char * {"\x1C"}
> +; CHECK: const char * {"\x1B"}
> +; CHECK: const char * {"\x1A"}
> +; CHECK: const char * {"\x19"}
> +; CHECK: const char * {"\x18"}
> +; CHECK: const char * {"\x17"}
> +; CHECK: const char * {"\x16"}
> +; CHECK: const char * {"\x15"}
> +; CHECK: const char * {"\x14"}
> +; CHECK: const char * {"\x13"}
> +; CHECK: const char * {"\x12"}
> +; CHECK: const char * {"\x11"}
> +; CHECK: const char * {"\x10"}
> +; CHECK: const char * {"\x0F"}
> +; CHECK: const char * {"\x0E"}
> +; CHECK: const char * {"\r"}
> +; CHECK: const char * {"\f"}
> +; CHECK: const char * {"\v"}
> +; CHECK: const char * {"\n"}
> +; CHECK: const char * {"\t"}
> +; CHECK: const char * {"\b"}
> +; CHECK: const char * {"\a"}
> +; CHECK: const char * {"\x06"}
> +; CHECK: const char * {"\x05"}
> +; CHECK: const char * {"\x04"}
> +; CHECK: const char * {"\x03"}
> +; CHECK: const char * {"\x02"}
> +; CHECK: const char * {"\x01"}
> +; CHECK: const char * {"\x00"}
> +
> +
> +??_C at _13KDLDGPGJ@?$AA?7?$AA?$AA@
> +??_C at _13LBAGMAIH@?$AA?6?$AA?$AA@
> +??_C at _13JLKKHOC@?$AA?$AL?$AA?$AA@
> +??_C at _13HOIJIPNN@?$AA?5?$AA?$AA@
> +??_C at _13MGDFOILI@?$AA?$CB?$AA?$AA@
> +??_C at _13NEIAEHFG@?$AA?$CC?$AA?$AA@
> +??_C at _13GMDMCADD@?$AA?$CD?$AA?$AA@
> +??_C at _13PBOLBIIK@?$AA$?$AA?$AA@
> +??_C at _13EJFHHPOP@?$AA?$CF?$AA?$AA@
> +??_C at _13FLOCNAAB@?$AA?$CG?$AA?$AA@
> +??_C at _13ODFOLHGE@?$AA?8?$AA?$AA@
> +??_C at _13LLDNKHDC@?$AA?$CI?$AA?$AA@
> +??_C at _13DIBMAFH@?$AA?$CJ?$AA?$AA@
> +??_C at _13BBDEGPLJ@?$AA?$CK?$AA?$AA@
> +??_C at _13KJIIAINM@?$AA?$CL?$AA?$AA@
> +??_C at _13DEFPDAGF@?$AA?0?$AA?$AA@
> +??_C at _13IMODFHAA@?$AA?9?$AA?$AA@
> +??_C at _13JOFGPIOO@?$AA?4?$AA?$AA@
> +??_C at _13CGOKJPIL@?$AA?1?$AA?$AA@
> +??_C at _13COJANIEC@?$AA0?$AA?$AA@
> +??_C at _13JGCMLPCH@?$AA1?$AA?$AA@
> +??_C at _13IEJJBAMJ@?$AA2?$AA?$AA@
> +??_C at _13DMCFHHKM@?$AA3?$AA?$AA@
> +??_C at _13KBPCEPBF@?$AA4?$AA?$AA@
> +??_C at _13BJEOCIHA@?$AA5?$AA?$AA@
> +??_C at _13LPLIHJO@?$AA6?$AA?$AA@
> +??_C at _13LDEHOAPL@?$AA7?$AA?$AA@
> +??_C at _13OLCEPAKN@?$AA8?$AA?$AA@
> +??_C at _13FDJIJHMI@?$AA9?$AA?$AA@
> +??_C at _13EBCNDICG@?$AA?3?$AA?$AA@
> +??_C at _13PJJBFPED@?$AA?$DL?$AA?$AA@
> +??_C at _13GEEGGHPK@?$AA?$DM?$AA?$AA@
> +??_C at _13NMPKAAJP@?$AA?$DN?$AA?$AA@
> +??_C at _13MOEPKPHB@?$AA?$DO?$AA?$AA@
> +??_C at _13HGPDMIBE@?$AA?$DP?$AA?$AA@
> +??_C at _13EFKPHINO@?$AA?$EA?$AA?$AA@
> +??_C at _13PNBDBPLL@?$AAA?$AA?$AA@
> +??_C at _13OPKGLAFF@?$AAB?$AA?$AA@
> +??_C at _13FHBKNHDA@?$AAC?$AA?$AA@
> +??_C at _13MKMNOPIJ@?$AAD?$AA?$AA@
> +??_C at _13HCHBIIOM@?$AAE?$AA?$AA@
> +??_C at _13GAMECHAC@?$AAF?$AA?$AA@
> +??_C at _13NIHIEAGH@?$AAG?$AA?$AA@
> +??_C at _13IABLFADB@?$AAH?$AA?$AA@
> +??_C at _13DIKHDHFE@?$AAI?$AA?$AA@
> +??_C at _13CKBCJILK@?$AAJ?$AA?$AA@
> +??_C at _13JCKOPPNP@?$AAK?$AA?$AA@
> +??_C at _13PHJMHGG@?$AAL?$AA?$AA@
> +??_C at _13LHMFKAAD@?$AAM?$AA?$AA@
> +??_C at _13KFHAAPON@?$AAN?$AA?$AA@
> +??_C at _13BNMMGIII@?$AAO?$AA?$AA@
> +??_C at _13BFLGCPEB@?$AAP?$AA?$AA@
> +??_C at _13KNAKEICE@?$AAQ?$AA?$AA@
> +??_C at _13LPLPOHMK@?$AAR?$AA?$AA@
> +??_C at _13HADIAKP@?$AAS?$AA?$AA@
> +??_C at _13JKNELIBG@?$AAT?$AA?$AA@
> +??_C at _13CCGINPHD@?$AAU?$AA?$AA@
> +??_C at _13DANNHAJN@?$AAV?$AA?$AA@
> +??_C at _13IIGBBHPI@?$AAW?$AA?$AA@
> +??_C at _13NAACAHKO@?$AAX?$AA?$AA@
> +??_C at _13GILOGAML@?$AAY?$AA?$AA@
> +??_C at _13HKALMPCF@?$AAZ?$AA?$AA@
> +??_C at _13MCLHKIEA@?$AA?$FL?$AA?$AA@
> +??_C at _13FPGAJAPJ@?$AA?2?$AA?$AA@
> +??_C at _13OHNMPHJM@?$AA?$FN?$AA?$AA@
> +??_C at _13PFGJFIHC@?$AA?$FO?$AA?$AA@
> +??_C at _13ENNFDPBH@?$AA_?$AA?$AA@
> +??_C at _13OFJNNHOA@?$AA?$GA?$AA?$AA@
> +??_C at _13FNCBLAIF@?$AAa?$AA?$AA@
> +??_C at _13EPJEBPGL@?$AAb?$AA?$AA@
> +??_C at _13PHCIHIAO@?$AAc?$AA?$AA@
> +??_C at _13GKPPEALH@?$AAd?$AA?$AA@
> +??_C at _13NCEDCHNC@?$AAe?$AA?$AA@
> +??_C at _13MAPGIIDM@?$AAf?$AA?$AA@
> +??_C at _13HIEKOPFJ@?$AAg?$AA?$AA@
> +??_C at _13CACJPPAP@?$AAh?$AA?$AA@
> +??_C at _13JIJFJIGK@?$AAi?$AA?$AA@
> +??_C at _13IKCADHIE@?$AAj?$AA?$AA@
> +??_C at _13DCJMFAOB@?$AAk?$AA?$AA@
> +??_C at _13KPELGIFI@?$AAl?$AA?$AA@
> +??_C at _13BHPHAPDN@?$AAm?$AA?$AA@
> +??_C at _13FECKAND@?$AAn?$AA?$AA@
> +??_C at _13LNPOMHLG@?$AAo?$AA?$AA@
> +??_C at _13LFIEIAHP@?$AAp?$AA?$AA@
> +??_C at _13NDIOHBK@?$AAq?$AA?$AA@
> +??_C at _13BPINEIPE@?$AAr?$AA?$AA@
> +??_C at _13KHDBCPJB@?$AAs?$AA?$AA@
> +??_C at _13DKOGBHCI@?$AAt?$AA?$AA@
> +??_C at _13ICFKHAEN@?$AAu?$AA?$AA@
> +??_C at _13JAOPNPKD@?$AAv?$AA?$AA@
> +??_C at _13CIFDLIMG@?$AAw?$AA?$AA@
> +??_C at _13HADAKIJA@?$AAx?$AA?$AA@
> +??_C at _13MIIMMPPF@?$AAy?$AA?$AA@
> +??_C at _13NKDJGABL@?$AAz?$AA?$AA@
> +??_C at _13GCIFAHHO@?$AA?$HL?$AA?$AA@
> +??_C at _13PPFCDPMH@?$AA?$HM?$AA?$AA@
> +??_C at _13EHOOFIKC@?$AA?$HN?$AA?$AA@
> +??_C at _13FFFLPHEM@?$AA?$HO?$AA?$AA@
> +
> +; CHECK: const wchar_t * {L"\t"}
> +; CHECK: const wchar_t * {L"\n"}
> +; CHECK: const wchar_t * {L"\v"}
> +; CHECK: const wchar_t * {L" "}
> +; CHECK: const wchar_t * {L"!"}
> +; CHECK: const wchar_t * {L"\""}
> +; CHECK: const wchar_t * {L"#"}
> +; CHECK: const wchar_t * {L"$"}
> +; CHECK: const wchar_t * {L"%"}
> +; CHECK: const wchar_t * {L"&"}
> +; CHECK: const wchar_t * {L"\'"}
> +; CHECK: const wchar_t * {L"("}
> +; CHECK: const wchar_t * {L")"}
> +; CHECK: const wchar_t * {L"*"}
> +; CHECK: const wchar_t * {L"+"}
> +; CHECK: const wchar_t * {L","}
> +; CHECK: const wchar_t * {L"-"}
> +; CHECK: const wchar_t * {L"."}
> +; CHECK: const wchar_t * {L"/"}
> +; CHECK: const wchar_t * {L"0"}
> +; CHECK: const wchar_t * {L"1"}
> +; CHECK: const wchar_t * {L"2"}
> +; CHECK: const wchar_t * {L"3"}
> +; CHECK: const wchar_t * {L"4"}
> +; CHECK: const wchar_t * {L"5"}
> +; CHECK: const wchar_t * {L"6"}
> +; CHECK: const wchar_t * {L"7"}
> +; CHECK: const wchar_t * {L"8"}
> +; CHECK: const wchar_t * {L"9"}
> +; CHECK: const wchar_t * {L":"}
> +; CHECK: const wchar_t * {L";"}
> +; CHECK: const wchar_t * {L"<"}
> +; CHECK: const wchar_t * {L"="}
> +; CHECK: const wchar_t * {L">"}
> +; CHECK: const wchar_t * {L"?"}
> +; CHECK: const wchar_t * {L"@"}
> +; CHECK: const wchar_t * {L"A"}
> +; CHECK: const wchar_t * {L"B"}
> +; CHECK: const wchar_t * {L"C"}
> +; CHECK: const wchar_t * {L"D"}
> +; CHECK: const wchar_t * {L"E"}
> +; CHECK: const wchar_t * {L"F"}
> +; CHECK: const wchar_t * {L"G"}
> +; CHECK: const wchar_t * {L"H"}
> +; CHECK: const wchar_t * {L"I"}
> +; CHECK: const wchar_t * {L"J"}
> +; CHECK: const wchar_t * {L"K"}
> +; CHECK: const wchar_t * {L"L"}
> +; CHECK: const wchar_t * {L"M"}
> +; CHECK: const wchar_t * {L"N"}
> +; CHECK: const wchar_t * {L"O"}
> +; CHECK: const wchar_t * {L"P"}
> +; CHECK: const wchar_t * {L"Q"}
> +; CHECK: const wchar_t * {L"R"}
> +; CHECK: const wchar_t * {L"S"}
> +; CHECK: const wchar_t * {L"T"}
> +; CHECK: const wchar_t * {L"U"}
> +; CHECK: const wchar_t * {L"V"}
> +; CHECK: const wchar_t * {L"W"}
> +; CHECK: const wchar_t * {L"X"}
> +; CHECK: const wchar_t * {L"Y"}
> +; CHECK: const wchar_t * {L"Z"}
> +; CHECK: const wchar_t * {L"["}
> +; CHECK: const wchar_t * {L"\\"}
> +; CHECK: const wchar_t * {L"]"}
> +; CHECK: const wchar_t * {L"^"}
> +; CHECK: const wchar_t * {L"_"}
> +; CHECK: const wchar_t * {L"`"}
> +; CHECK: const wchar_t * {L"a"}
> +; CHECK: const wchar_t * {L"b"}
> +; CHECK: const wchar_t * {L"c"}
> +; CHECK: const wchar_t * {L"d"}
> +; CHECK: const wchar_t * {L"e"}
> +; CHECK: const wchar_t * {L"f"}
> +; CHECK: const wchar_t * {L"g"}
> +; CHECK: const wchar_t * {L"h"}
> +; CHECK: const wchar_t * {L"i"}
> +; CHECK: const wchar_t * {L"j"}
> +; CHECK: const wchar_t * {L"k"}
> +; CHECK: const wchar_t * {L"l"}
> +; CHECK: const wchar_t * {L"m"}
> +; CHECK: const wchar_t * {L"n"}
> +; CHECK: const wchar_t * {L"o"}
> +; CHECK: const wchar_t * {L"p"}
> +; CHECK: const wchar_t * {L"q"}
> +; CHECK: const wchar_t * {L"r"}
> +; CHECK: const wchar_t * {L"s"}
> +; CHECK: const wchar_t * {L"t"}
> +; CHECK: const wchar_t * {L"u"}
> +; CHECK: const wchar_t * {L"v"}
> +; CHECK: const wchar_t * {L"w"}
> +; CHECK: const wchar_t * {L"x"}
> +; CHECK: const wchar_t * {L"y"}
> +; CHECK: const wchar_t * {L"z"}
> +; CHECK: const wchar_t * {L"{"}
> +; CHECK: const wchar_t * {L"|"}
> +; CHECK: const wchar_t * {L"}"}
> +; CHECK: const wchar_t * {L"~"}
> +
> +
> +
> +??_C at _0CF@LABBIIMO at 012345678901234567890123456789AB@
> +; CHECK: const char * {"012345678901234567890123456789AB"...}
> +
> +??_C at _1EK@KFPEBLPK
> @?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AAA?$AAB@
> +; CHECK: const wchar_t * {L"012345678901234567890123456789AB"...}
> +
> +??_C at _13IIHIAFKH@?W?$PP?$AA?$AA@
> +; CHECK: const wchar_t * {L"\xD7\xFF"}
> +
> +??_C at _02PCEFGMJL@hi?$AA@
> +; CHECK: const char * {"hi"}
> +
> +??_C at _05OMLEGLOC@h?$AAi?$AA?$AA?$AA@
> +; CHECK: const char16_t * {u"hi"}
> +
> +??_C at _0EK@FEAOBHPP
> @o?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA@
> +; CHECK: const char16_t * {u"o123456789012345"...}
> +
> +??_C at _0M@GFNAJIPG at h?$AA?$AA?$AAi?$AA?$AA?$AA?$AA?$AA?$AA?$AA@
> +; CHECK: const char32_t * {U"hi"}
> +
> +??_C at _0JE@IMHFEDAA
> @0?$AA?$AA?$AA1?$AA?$AA?$AA2?$AA?$AA?$AA3?$AA?$AA?$AA4?$AA?$AA?$AA5?$AA?$AA?$AA6?$AA?$AA?$AA7?$AA?$AA?$AA@
> +; CHECK: const char32_t * {U"01234567"...}
> +
> +; These all have just the right length that the trailing 0 just fits.
> +??_C at _0CA@NMANGEKF at 012345678901234567890123456789A?$AA@
> +; CHECK: const char * {"012345678901234567890123456789A"}
> +
> +??_C at _1EA@LJAFPILO
> @?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AAA?$AA?$AA@
> +; CHECK: const wchar_t * {L"012345678901234567890123456789A"}
> +
> +??_C at _0CA@NMANGEKF at 012345678901234567890123456789A?$AA@
> +; CHECK: const char * {"012345678901234567890123456789A"}
> +
> +??_C at _0CA@NFEFHIFO
> @0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA?$AA?$AA@
> +; CHECK: const char16_t * {u"012345678901234"}
> +
> +??_C at _0CA@KFPHPCC
> @0?$AA?$AA?$AA1?$AA?$AA?$AA2?$AA?$AA?$AA3?$AA?$AA?$AA4?$AA?$AA?$AA5?$AA?$AA?$AA6?$AA?$AA?$AA?$AA?$AA?$AA?$AA@
> +; CHECK: const char32_t * {U"0123456"}
> \ No newline at end of file
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20180816/0fe76ac9/attachment.html>
More information about the llvm-commits
mailing list