Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- SymbolRemappingReader.h - Read symbol remapping file -----*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This file contains definitions needed for reading and applying symbol
  10. // remapping files.
  11. //
  12. // Support is provided only for the Itanium C++ name mangling scheme for now.
  13. //
  14. // NOTE: If you are making changes to this file format, please remember
  15. //       to document them in the Clang documentation at
  16. //       tools/clang/docs/UsersManual.rst.
  17. //
  18. // File format
  19. // -----------
  20. //
  21. // The symbol remappings are written as an ASCII text file. Blank lines and
  22. // lines starting with a # are ignored. All other lines specify a kind of
  23. // mangled name fragment, along with two fragments of that kind that should
  24. // be treated as equivalent, separated by spaces.
  25. //
  26. // See http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling for a
  27. // description of the Itanium name mangling scheme.
  28. //
  29. // The accepted fragment kinds are:
  30. //
  31. //  * name  A <name>, such as 6foobar or St3__1
  32. //  * type  A <type>, such as Ss or N4llvm9StringRefE
  33. //  * encoding  An <encoding> (a complete mangling without the leading _Z)
  34. //
  35. // For example:
  36. //
  37. // # Ignore int / long differences to treat symbols from 32-bit and 64-bit
  38. // # builds with differing size_t / ptrdiff_t / intptr_t as equivalent.
  39. // type i l
  40. // type j m
  41. //
  42. // # Ignore differences between libc++ and libstdc++, and between libstdc++'s
  43. // # C++98 and C++11 ABIs.
  44. // name 3std St3__1
  45. // name 3std St7__cxx11
  46. //
  47. // # Remap a function overload to a specialization of a template (including
  48. // # any local symbols declared within it).
  49. // encoding N2NS1fEi N2NS1fIiEEvT_
  50. //
  51. // # Substitutions must be remapped separately from namespace 'std' for now.
  52. // name Sa NSt3__19allocatorE
  53. // name Sb NSt3__112basic_stringE
  54. // type Ss NSt3__112basic_stringIcSt11char_traitsIcESaE
  55. // # ...
  56. //
  57. //===----------------------------------------------------------------------===//
  58.  
  59. #ifndef LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
  60. #define LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
  61.  
  62. #include "llvm/ADT/StringRef.h"
  63. #include "llvm/Support/Error.h"
  64. #include "llvm/Support/ItaniumManglingCanonicalizer.h"
  65.  
  66. namespace llvm {
  67.  
  68. class MemoryBuffer;
  69.  
  70. class SymbolRemappingParseError : public ErrorInfo<SymbolRemappingParseError> {
  71. public:
  72.   SymbolRemappingParseError(StringRef File, int64_t Line, const Twine &Message)
  73.       : File(File), Line(Line), Message(Message.str()) {}
  74.  
  75.   void log(llvm::raw_ostream &OS) const override {
  76.     OS << File << ':' << Line << ": " << Message;
  77.   }
  78.   std::error_code convertToErrorCode() const override {
  79.     return llvm::inconvertibleErrorCode();
  80.   }
  81.  
  82.   StringRef getFileName() const { return File; }
  83.   int64_t getLineNum() const { return Line; }
  84.   StringRef getMessage() const { return Message; }
  85.  
  86.   static char ID;
  87.  
  88. private:
  89.   std::string File;
  90.   int64_t Line;
  91.   std::string Message;
  92. };
  93.  
  94. /// Reader for symbol remapping files.
  95. ///
  96. /// Remaps the symbol names in profile data to match those in the program
  97. /// according to a set of rules specified in a given file.
  98. class SymbolRemappingReader {
  99. public:
  100.   /// Read remappings from the given buffer, which must live as long as
  101.   /// the remapper.
  102.   Error read(MemoryBuffer &B);
  103.  
  104.   /// A Key represents an equivalence class of symbol names.
  105.   using Key = uintptr_t;
  106.  
  107.   /// Construct a key for the given symbol, or return an existing one if an
  108.   /// equivalent name has already been inserted. The symbol name must live
  109.   /// as long as the remapper.
  110.   ///
  111.   /// The result will be Key() if the name cannot be remapped (typically
  112.   /// because it is not a valid mangled name).
  113.   Key insert(StringRef FunctionName) {
  114.     return Canonicalizer.canonicalize(FunctionName);
  115.   }
  116.  
  117.   /// Map the given symbol name into the key for the corresponding equivalence
  118.   /// class.
  119.   ///
  120.   /// The result will typically be Key() if no equivalent symbol has been
  121.   /// inserted, but this is not guaranteed: a Key different from all keys ever
  122.   /// returned by \c insert may be returned instead.
  123.   Key lookup(StringRef FunctionName) {
  124.     return Canonicalizer.lookup(FunctionName);
  125.   }
  126.  
  127. private:
  128.   ItaniumManglingCanonicalizer Canonicalizer;
  129. };
  130.  
  131. } // end namespace llvm
  132.  
  133. #endif // LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
  134.