Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- 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_SUPPORT_SYMBOLREMAPPINGREADER_H

#define LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H

#include "llvm/ADT/StringRef.h"

#include "llvm/Support/Error.h"

#include "llvm/Support/ItaniumManglingCanonicalizer.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_SUPPORT_SYMBOLREMAPPINGREADER_H