mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-23 04:52:54 +02:00
91cdab6916
This patch re-introduces the MCContext member that was removed from MCDisassembler in r206063, and requires that an MCContext be passed in at MCDisassembler construction time. (Previously the MCContext member had been initialized in an ad-hoc fashion after construction). The MCCContext member can be used by MCDisassembler sub-classes to construct constant or target-specific MCExprs. This patch updates disassemblers for in-tree targets, and provides the MCRegisterInfo instance that some disassemblers were using through the MCContext (previously those backends were constructing their own MCRegisterInfo instances). llvm-svn: 206241
119 lines
4.6 KiB
C++
119 lines
4.6 KiB
C++
//===-- llvm/MC/MCDisassembler.h - Disassembler interface -------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#ifndef LLVM_MC_MCDISASSEMBLER_H
|
|
#define LLVM_MC_MCDISASSEMBLER_H
|
|
|
|
#include "llvm-c/Disassembler.h"
|
|
#include "llvm/ADT/OwningPtr.h"
|
|
#include "llvm/MC/MCRelocationInfo.h"
|
|
#include "llvm/MC/MCSymbolizer.h"
|
|
#include "llvm/Support/DataTypes.h"
|
|
|
|
namespace llvm {
|
|
|
|
class MCInst;
|
|
class MCSubtargetInfo;
|
|
class MemoryObject;
|
|
class raw_ostream;
|
|
class MCContext;
|
|
|
|
/// MCDisassembler - Superclass for all disassemblers. Consumes a memory region
|
|
/// and provides an array of assembly instructions.
|
|
class MCDisassembler {
|
|
public:
|
|
/// Ternary decode status. Most backends will just use Fail and
|
|
/// Success, however some have a concept of an instruction with
|
|
/// understandable semantics but which is architecturally
|
|
/// incorrect. An example of this is ARM UNPREDICTABLE instructions
|
|
/// which are disassemblable but cause undefined behaviour.
|
|
///
|
|
/// Because it makes sense to disassemble these instructions, there
|
|
/// is a "soft fail" failure mode that indicates the MCInst& is
|
|
/// valid but architecturally incorrect.
|
|
///
|
|
/// The enum numbers are deliberately chosen such that reduction
|
|
/// from Success->SoftFail ->Fail can be done with a simple
|
|
/// bitwise-AND:
|
|
///
|
|
/// LEFT & TOP = | Success Unpredictable Fail
|
|
/// --------------+-----------------------------------
|
|
/// Success | Success Unpredictable Fail
|
|
/// Unpredictable | Unpredictable Unpredictable Fail
|
|
/// Fail | Fail Fail Fail
|
|
///
|
|
/// An easy way of encoding this is as 0b11, 0b01, 0b00 for
|
|
/// Success, SoftFail, Fail respectively.
|
|
enum DecodeStatus {
|
|
Fail = 0,
|
|
SoftFail = 1,
|
|
Success = 3
|
|
};
|
|
|
|
/// Constructor - Performs initial setup for the disassembler.
|
|
MCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
|
|
: Ctx(Ctx), STI(STI), Symbolizer(), CommentStream(nullptr) {}
|
|
|
|
virtual ~MCDisassembler();
|
|
|
|
/// getInstruction - Returns the disassembly of a single instruction.
|
|
///
|
|
/// @param instr - An MCInst to populate with the contents of the
|
|
/// instruction.
|
|
/// @param size - A value to populate with the size of the instruction, or
|
|
/// the number of bytes consumed while attempting to decode
|
|
/// an invalid instruction.
|
|
/// @param region - The memory object to use as a source for machine code.
|
|
/// @param address - The address, in the memory space of region, of the first
|
|
/// byte of the instruction.
|
|
/// @param vStream - The stream to print warnings and diagnostic messages on.
|
|
/// @param cStream - The stream to print comments and annotations on.
|
|
/// @return - MCDisassembler::Success if the instruction is valid,
|
|
/// MCDisassembler::SoftFail if the instruction was
|
|
/// disassemblable but invalid,
|
|
/// MCDisassembler::Fail if the instruction was invalid.
|
|
virtual DecodeStatus getInstruction(MCInst& instr,
|
|
uint64_t& size,
|
|
const MemoryObject ®ion,
|
|
uint64_t address,
|
|
raw_ostream &vStream,
|
|
raw_ostream &cStream) const = 0;
|
|
private:
|
|
MCContext &Ctx;
|
|
|
|
protected:
|
|
// Subtarget information, for instruction decoding predicates if required.
|
|
const MCSubtargetInfo &STI;
|
|
std::unique_ptr<MCSymbolizer> Symbolizer;
|
|
|
|
public:
|
|
// Helpers around MCSymbolizer
|
|
bool tryAddingSymbolicOperand(MCInst &Inst,
|
|
int64_t Value,
|
|
uint64_t Address, bool IsBranch,
|
|
uint64_t Offset, uint64_t InstSize) const;
|
|
|
|
void tryAddingPcLoadReferenceComment(int64_t Value, uint64_t Address) const;
|
|
|
|
/// Set \p Symzer as the current symbolizer.
|
|
/// This takes ownership of \p Symzer, and deletes the previously set one.
|
|
void setSymbolizer(std::unique_ptr<MCSymbolizer> Symzer);
|
|
|
|
MCContext& getContext() const { return Ctx; }
|
|
|
|
const MCSubtargetInfo& getSubtargetInfo() const { return STI; }
|
|
|
|
// Marked mutable because we cache it inside the disassembler, rather than
|
|
// having to pass it around as an argument through all the autogenerated code.
|
|
mutable raw_ostream *CommentStream;
|
|
};
|
|
|
|
} // namespace llvm
|
|
|
|
#endif
|