FormatterBytecode.h

Go to the documentation of this file.

//===-- FormatterBytecode.h -------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
 
#ifndef LLDB_DATAFORMATTERS_FORMATTERBYTECODE_H
#define LLDB_DATAFORMATTERS_FORMATTERBYTECODE_H
 
#include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Symbol/CompilerType.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/StringMap.h"
#include <memory>
 
namespace lldb_private {
 
namespace FormatterBytecode {
 
enum DataType : uint8_t {
  Any,
  String,
  Int,  ///< Deprecated: use Integer.
  UInt, ///< Deprecated: use Integer.
  Object,
  Type,
  Selector,
  Integer,
  // Named `Dict` to avoid colliding with the `Dictionary` class, since this
  // enumerator is scoped to the enclosing namespace.
  Dict,
};
 
enum OpCodes : uint8_t {
#define DEFINE_OPCODE(OP, MNEMONIC, NAME) op_##NAME = OP,
#include "FormatterBytecode.def"
#undef DEFINE_OPCODE
};
 
enum Selectors : uint8_t {
#define DEFINE_SELECTOR(ID, NAME) sel_##NAME = ID,
#include "FormatterBytecode.def"
#undef DEFINE_SELECTOR
};
 
enum Signatures : uint8_t {
#define DEFINE_SIGNATURE(ID, NAME) sig_##NAME = ID,
#include "FormatterBytecode.def"
#undef DEFINE_SIGNATURE
};
 
using ControlStackElement = llvm::StringRef;
using ControlStack = std::vector<ControlStackElement>;
 
// A Dictionary mapping String keys to DataStackElements. It is always wrapped
// in a shared_ptr for two reasons:
//   1. To allow DataStackElement to hold a dictionary, breaking the type
//   reference cyle.
//   2. To provide reference type behavior. This means `op_dict_set` can mutate
//   the same instance that other stack slots refer to (ex via `dup`).
class Dictionary;
using DictionarySP = std::shared_ptr<Dictionary>;
 
// uint64_t and int64_t are kept for compatibility with the deprecated
// uint/int opcodes. New code should instead use APSInt (op_lit_integer).
using DataStackElement =
    std::variant<std::string, uint64_t, int64_t, lldb::ValueObjectSP,
                 CompilerType, Selectors, llvm::APSInt, DictionarySP>;
 
class Dictionary : public llvm::StringMap<DataStackElement> {};
 
struct DataStack : public std::vector<DataStackElement> {
  DataStack() = default;
  DataStack(lldb::ValueObjectSP initial_value)
      : std::vector<DataStackElement>({initial_value}) {}
  void Push(DataStackElement el) { push_back(el); }
  template <typename T> T Pop() {
    T el = std::get<T>(back());
    pop_back();
    return el;
  }
  DataStackElement PopAny() {
    DataStackElement el = back();
    pop_back();
    return el;
  }
};
 
llvm::Error Interpret(ControlStack &control, DataStack &data, Signatures sig);
 
} // namespace FormatterBytecode
 
std::string toString(FormatterBytecode::OpCodes op);
std::string toString(FormatterBytecode::Selectors sel);
std::string toString(FormatterBytecode::Signatures sig);
 
} // namespace lldb_private
 
#endif