Line data    Source code

       1             : //===- SymbolRemappingReader.h - Read symbol remapping file -----*- C++ -*-===//
       2             : //
       3             : //                      The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file contains definitions needed for reading and applying symbol
      11             : // remapping files.
      12             : //
      13             : // Support is provided only for the Itanium C++ name mangling scheme for now.
      14             : //
      15             : // NOTE: If you are making changes to this file format, please remember
      16             : //       to document them in the Clang documentation at
      17             : //       tools/clang/docs/UsersManual.rst.
      18             : //
      19             : // File format
      20             : // -----------
      21             : //
      22             : // The symbol remappings are written as an ASCII text file. Blank lines and
      23             : // lines starting with a # are ignored. All other lines specify a kind of
      24             : // mangled name fragment, along with two fragments of that kind that should
      25             : // be treated as equivalent, separated by spaces.
      26             : //
      27             : // See http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling for a
      28             : // description of the Itanium name mangling scheme.
      29             : //
      30             : // The accepted fragment kinds are:
      31             : //
      32             : //  * name  A <name>, such as 6foobar or St3__1
      33             : //  * type  A <type>, such as Ss or N4llvm9StringRefE
      34             : //  * encoding  An <encoding> (a complete mangling without the leading _Z)
      35             : //
      36             : // For example:
      37             : //
      38             : // # Ignore int / long differences to treat symbols from 32-bit and 64-bit
      39             : // # builds with differing size_t / ptrdiff_t / intptr_t as equivalent.
      40             : // type i l
      41             : // type j m
      42             : //
      43             : // # Ignore differences between libc++ and libstdc++, and between libstdc++'s
      44             : // # C++98 and C++11 ABIs.
      45             : // name 3std St3__1
      46             : // name 3std St7__cxx11
      47             : //
      48             : // # Remap a function overload to a specialization of a template (including
      49             : // # any local symbols declared within it).
      50             : // encoding N2NS1fEi N2NS1fIiEEvT_
      51             : //
      52             : // # Substitutions must be remapped separately from namespace 'std' for now.
      53             : // name Sa NSt3__19allocatorE
      54             : // name Sb NSt3__112basic_stringE
      55             : // type Ss NSt3__112basic_stringIcSt11char_traitsIcESaE
      56             : // # ...
      57             : //
      58             : //===----------------------------------------------------------------------===//
      59             : 
      60             : #ifndef LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
      61             : #define LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
      62             : 
      63             : #include "llvm/ADT/StringRef.h"
      64             : #include "llvm/Support/Error.h"
      65             : #include "llvm/Support/ItaniumManglingCanonicalizer.h"
      66             : #include "llvm/Support/MemoryBuffer.h"
      67             : 
      68             : namespace llvm {
      69             : 
      70             : class SymbolRemappingParseError : public ErrorInfo<SymbolRemappingParseError> {
      71             : public:
      72           7 :   SymbolRemappingParseError(StringRef File, int64_t Line, Twine Message)
      73          14 :       : File(File), Line(Line), Message(Message.str()) {}
      74             : 
      75           7 :   void log(llvm::raw_ostream &OS) const override {
      76           7 :     OS << File << ':' << Line << ": " << Message;
      77           7 :   }
      78           0 :   std::error_code convertToErrorCode() const override {
      79           0 :     return llvm::inconvertibleErrorCode();
      80             :   }
      81             : 
      82             :   StringRef getFileName() const { return File; }
      83           0 :   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          18 : 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          19 :     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          53 :     return Canonicalizer.lookup(FunctionName);
     125             :   }
     126             : 
     127             : private:
     128             :   ItaniumManglingCanonicalizer Canonicalizer;
     129             : };
     130             : 
     131             : } // end namespace llvm
     132             : 
     133             : #endif // LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H