EIC code displayed by LXR master/​include/​llvm/​ProfileData/​SymbolRemappingReader.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:44:25

 //===- SymbolRemappingReader.h - Read symbol remapping file -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains definitions needed for reading and applying symbol
 // remapping files.
 //
 // Support is provided only for the Itanium C++ name mangling scheme for now.
 //
 // NOTE: If you are making changes to this file format, please remember
 //       to document them in the Clang documentation at
 //       tools/clang/docs/UsersManual.rst.
 //
 // File format
 // -----------
 //
 // The symbol remappings are written as an ASCII text file. Blank lines and
 // lines starting with a # are ignored. All other lines specify a kind of
 // mangled name fragment, along with two fragments of that kind that should
 // be treated as equivalent, separated by spaces.
 //
 // See http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling for a
 // description of the Itanium name mangling scheme.
 //
 // The accepted fragment kinds are:
 //
 //  * name  A <name>, such as 6foobar or St3__1
 //  * type  A <type>, such as Ss or N4llvm9StringRefE
 //  * encoding  An <encoding> (a complete mangling without the leading _Z)
 //
 // For example:
 //
 // # Ignore int / long differences to treat symbols from 32-bit and 64-bit
 // # builds with differing size_t / ptrdiff_t / intptr_t as equivalent.
 // type i l
 // type j m
 //
 // # Ignore differences between libc++ and libstdc++, and between libstdc++'s
 // # C++98 and C++11 ABIs.
 // name 3std St3__1
 // name 3std St7__cxx11
 //
 // # Remap a function overload to a specialization of a template (including
 // # any local symbols declared within it).
 // encoding N2NS1fEi N2NS1fIiEEvT_
 //
 // # Substitutions must be remapped separately from namespace 'std' for now.
 // name Sa NSt3__19allocatorE
 // name Sb NSt3__112basic_stringE
 // type Ss NSt3__112basic_stringIcSt11char_traitsIcESaE
 // # ...
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PROFILEDATA_SYMBOLREMAPPINGREADER_H
 #define LLVM_PROFILEDATA_SYMBOLREMAPPINGREADER_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ProfileData/ItaniumManglingCanonicalizer.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 class MemoryBuffer;
 
 class SymbolRemappingParseError : public ErrorInfo<SymbolRemappingParseError> {
 public:
   SymbolRemappingParseError(StringRef File, int64_t Line, const Twine &Message)
       : File(File), Line(Line), Message(Message.str()) {}
 
   void log(llvm::raw_ostream &OS) const override {
     OS << File << ':' << Line << ": " << Message;
   }
   std::error_code convertToErrorCode() const override {
     return llvm::inconvertibleErrorCode();
   }
 
   StringRef getFileName() const { return File; }
   int64_t getLineNum() const { return Line; }
   StringRef getMessage() const { return Message; }
 
   static char ID;
 
 private:
   std::string File;
   int64_t Line;
   std::string Message;
 };
 
 /// Reader for symbol remapping files.
 ///
 /// Remaps the symbol names in profile data to match those in the program
 /// according to a set of rules specified in a given file.
 class SymbolRemappingReader {
 public:
   /// Read remappings from the given buffer, which must live as long as
   /// the remapper.
   Error read(MemoryBuffer &B);
 
   /// A Key represents an equivalence class of symbol names.
   using Key = uintptr_t;
 
   /// Construct a key for the given symbol, or return an existing one if an
   /// equivalent name has already been inserted. The symbol name must live
   /// as long as the remapper.
   ///
   /// The result will be Key() if the name cannot be remapped (typically
   /// because it is not a valid mangled name).
   Key insert(StringRef FunctionName) {
     return Canonicalizer.canonicalize(FunctionName);
   }
 
   /// Map the given symbol name into the key for the corresponding equivalence
   /// class.
   ///
   /// The result will typically be Key() if no equivalent symbol has been
   /// inserted, but this is not guaranteed: a Key different from all keys ever
   /// returned by \c insert may be returned instead.
   Key lookup(StringRef FunctionName) {
     return Canonicalizer.lookup(FunctionName);
   }
 
 private:
   ItaniumManglingCanonicalizer Canonicalizer;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_SYMBOLREMAPPINGREADER_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team