EmulateInstructionPPC64.h

Go to the documentation of this file.

//===-- EmulateInstructionPPC64.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_SOURCE_PLUGINS_INSTRUCTION_PPC64_EMULATEINSTRUCTIONPPC64_H
#define LLDB_SOURCE_PLUGINS_INSTRUCTION_PPC64_EMULATEINSTRUCTIONPPC64_H
 
#include "lldb/Core/EmulateInstruction.h"
#include "lldb/Interpreter/OptionValue.h"
#include "lldb/Utility/Log.h"
#include <optional>
 
namespace lldb_private {
 
class EmulateInstructionPPC64 : public EmulateInstruction {
public:
  EmulateInstructionPPC64(const ArchSpec &arch);
 
  static void Initialize();
 
  static void Terminate();
 
  static llvm::StringRef GetPluginNameStatic() { return "ppc64"; }
 
  static llvm::StringRef GetPluginDescriptionStatic();
 
  static EmulateInstruction *CreateInstance(const ArchSpec &arch,
                                            InstructionType inst_type);
 
  static bool
  SupportsEmulatingInstructionsOfTypeStatic(InstructionType inst_type) {
    switch (inst_type) {
    case eInstructionTypeAny:
    case eInstructionTypePrologueEpilogue:
      return true;
 
    case eInstructionTypePCModifying:
    case eInstructionTypeAll:
      return false;
    }
    return false;
  }
 
  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
  bool SetTargetTriple(const ArchSpec &arch) override;
 
  bool SupportsEmulatingInstructionsOfType(InstructionType inst_type) override {
    return SupportsEmulatingInstructionsOfTypeStatic(inst_type);
  }
 
  bool ReadInstruction() override;
 
  bool EvaluateInstruction(uint32_t evaluate_options) override;
 
  bool TestEmulation(Stream &out_stream, ArchSpec &arch,
                     OptionValueDictionary *test_data) override {
    return false;
  }
 
  std::optional<RegisterInfo> GetRegisterInfo(lldb::RegisterKind reg_kind,
                                              uint32_t reg_num) override;
 
  bool CreateFunctionEntryUnwind(UnwindPlan &unwind_plan) override;
 
private:
  struct Opcode {
    uint32_t mask;
    uint32_t value;
    bool (EmulateInstructionPPC64::*callback)(uint32_t opcode);
    const char *name;
  };
 
  uint32_t m_fp = LLDB_INVALID_REGNUM;
 
  Opcode *GetOpcodeForInstruction(uint32_t opcode);
 
  bool EmulateMFSPR(uint32_t opcode);
  bool EmulateLD(uint32_t opcode);
  bool EmulateSTD(uint32_t opcode);
  bool EmulateOR(uint32_t opcode);
  bool EmulateADDI(uint32_t opcode);
};
 
} // namespace lldb_private
 
#endif // LLDB_SOURCE_PLUGINS_INSTRUCTION_PPC64_EMULATEINSTRUCTIONPPC64_H