forked from OSchip/llvm-project
92 lines
3.0 KiB
C++
92 lines
3.0 KiB
C++
//===-EDOperand.h - LLVM Enhanced Disassembler ------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the interface for the Enhanced Disassembly library's
|
|
// operand class. The operand is responsible for allowing evaluation given a
|
|
// particular register context.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_EDOPERAND_H
|
|
#define LLVM_EDOPERAND_H
|
|
|
|
#include "llvm/System/DataTypes.h"
|
|
|
|
namespace llvm {
|
|
|
|
struct EDDisassembler;
|
|
struct EDInst;
|
|
|
|
typedef int (*EDRegisterReaderCallback)(uint64_t *value, unsigned regID,
|
|
void* arg);
|
|
|
|
|
|
/// EDOperand - Encapsulates a single operand, which can be evaluated by the
|
|
/// client
|
|
struct EDOperand {
|
|
/// The parent disassembler
|
|
const EDDisassembler &Disassembler;
|
|
/// The parent instruction
|
|
const EDInst &Inst;
|
|
|
|
/// The index of the operand in the EDInst
|
|
unsigned int OpIndex;
|
|
/// The index of the first component of the operand in the MCInst
|
|
unsigned int MCOpIndex;
|
|
|
|
/// Constructor - Initializes an EDOperand
|
|
///
|
|
/// @arg disassembler - The disassembler responsible for the operand
|
|
/// @arg inst - The instruction containing this operand
|
|
/// @arg opIndex - The index of the operand in inst
|
|
/// @arg mcOpIndex - The index of the operand in the original MCInst
|
|
EDOperand(const EDDisassembler &disassembler,
|
|
const EDInst &inst,
|
|
unsigned int opIndex,
|
|
unsigned int &mcOpIndex);
|
|
~EDOperand();
|
|
|
|
/// evaluate - Returns the numeric value of an operand to the extent possible,
|
|
/// returning 0 on success or -1 if there was some problem (such as a
|
|
/// register not being readable)
|
|
///
|
|
/// @arg result - A reference whose target is filled in with the value of
|
|
/// the operand (the address if it is a memory operand)
|
|
/// @arg callback - A function to call to obtain register values
|
|
/// @arg arg - An opaque argument to pass to callback
|
|
int evaluate(uint64_t &result,
|
|
EDRegisterReaderCallback callback,
|
|
void *arg);
|
|
|
|
/// isRegister - Returns 1 if the operand is a register or 0 otherwise
|
|
int isRegister();
|
|
/// regVal - Returns the register value.
|
|
unsigned regVal();
|
|
|
|
/// isImmediate - Returns 1 if the operand is an immediate or 0 otherwise
|
|
int isImmediate();
|
|
/// immediateVal - Returns the immediate value.
|
|
uint64_t immediateVal();
|
|
|
|
/// isMemory - Returns 1 if the operand is a memory location or 0 otherwise
|
|
int isMemory();
|
|
|
|
#ifdef __BLOCKS__
|
|
typedef int (^EDRegisterBlock_t)(uint64_t *value, unsigned regID);
|
|
|
|
/// evaluate - Like evaluate for a callback, but uses a block instead
|
|
int evaluate(uint64_t &result,
|
|
EDRegisterBlock_t regBlock);
|
|
#endif
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|