mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-23 02:29:18 +00:00
adjusted unittest I have added some doxygen to OptionalOperandTraits, so hopefully there will be no confusion in the future. Incidentally OptionalOperandTraits is not used any more (IIUC), but the obvious client would be BranchInstr, and I plan to rearrange it that way. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98624 91177308-0d34-0410-b5e6-96231b3b80d8
208 lines
7.2 KiB
C++
208 lines
7.2 KiB
C++
//===-- llvm/OperandTraits.h - OperandTraits class definition ---*- 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 traits classes that are handy for enforcing the correct
|
|
// layout of various User subclasses. It also provides the means for accessing
|
|
// the operands in the most efficient manner.
|
|
//
|
|
|
|
#ifndef LLVM_OPERAND_TRAITS_H
|
|
#define LLVM_OPERAND_TRAITS_H
|
|
|
|
#include "llvm/User.h"
|
|
|
|
namespace llvm {
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FixedNumOperand Trait Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// FixedNumOperandTraits - determine the allocation regime of the Use array
|
|
/// when it is a prefix to the User object, and the number of Use objects is
|
|
/// known at compile time.
|
|
|
|
template <unsigned ARITY>
|
|
struct FixedNumOperandTraits {
|
|
static Use *op_begin(User* U) {
|
|
return reinterpret_cast<Use*>(U) - ARITY;
|
|
}
|
|
static Use *op_end(User* U) {
|
|
return reinterpret_cast<Use*>(U);
|
|
}
|
|
static unsigned operands(const User*) {
|
|
return ARITY;
|
|
}
|
|
struct prefix {
|
|
Use Ops[ARITY];
|
|
prefix(); // DO NOT IMPLEMENT
|
|
};
|
|
template <class U>
|
|
struct Layout {
|
|
struct overlay : public prefix, public U {
|
|
overlay(); // DO NOT IMPLEMENT
|
|
};
|
|
};
|
|
};
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// OptionalOperand Trait Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// OptionalOperandTraits - when the number of operands may change at runtime.
|
|
/// Naturally it may only decrease, because the allocations may not change.
|
|
|
|
template <unsigned ARITY = 1>
|
|
struct OptionalOperandTraits : public FixedNumOperandTraits<ARITY> {
|
|
static unsigned operands(const User *U) {
|
|
return U->getNumOperands();
|
|
}
|
|
};
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// VariadicOperand Trait Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// VariadicOperandTraits - determine the allocation regime of the Use array
|
|
/// when it is a prefix to the User object, and the number of Use objects is
|
|
/// only known at allocation time.
|
|
|
|
template <unsigned MINARITY = 0>
|
|
struct VariadicOperandTraits {
|
|
static Use *op_begin(User* U) {
|
|
return reinterpret_cast<Use*>(U) - U->getNumOperands();
|
|
}
|
|
static Use *op_end(User* U) {
|
|
return reinterpret_cast<Use*>(U);
|
|
}
|
|
static unsigned operands(const User *U) {
|
|
return U->getNumOperands();
|
|
}
|
|
};
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// HungoffOperand Trait Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// HungoffOperandTraits - determine the allocation regime of the Use array
|
|
/// when it is not a prefix to the User object, but allocated at an unrelated
|
|
/// heap address.
|
|
/// Assumes that the User subclass that is determined by this traits class
|
|
/// has an OperandList member of type User::op_iterator. [Note: this is now
|
|
/// trivially satisfied, because User has that member for historic reasons.]
|
|
///
|
|
/// This is the traits class that is needed when the Use array must be
|
|
/// resizable.
|
|
|
|
template <unsigned MINARITY = 1>
|
|
struct HungoffOperandTraits {
|
|
static Use *op_begin(User* U) {
|
|
return U->OperandList;
|
|
}
|
|
static Use *op_end(User* U) {
|
|
return U->OperandList + U->getNumOperands();
|
|
}
|
|
static unsigned operands(const User *U) {
|
|
return U->getNumOperands();
|
|
}
|
|
};
|
|
|
|
/// Macro for generating in-class operand accessor declarations.
|
|
/// It should only be called in the public section of the interface.
|
|
///
|
|
#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS) \
|
|
public: \
|
|
inline VALUECLASS *getOperand(unsigned) const; \
|
|
inline void setOperand(unsigned, VALUECLASS*); \
|
|
inline op_iterator op_begin(); \
|
|
inline const_op_iterator op_begin() const; \
|
|
inline op_iterator op_end(); \
|
|
inline const_op_iterator op_end() const; \
|
|
protected: \
|
|
template <int> inline Use &Op(); \
|
|
template <int> inline const Use &Op() const; \
|
|
public: \
|
|
inline unsigned getNumOperands() const
|
|
|
|
/// Macro for generating out-of-class operand accessor definitions
|
|
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
|
|
CLASS::op_iterator CLASS::op_begin() { \
|
|
return OperandTraits<CLASS>::op_begin(this); \
|
|
} \
|
|
CLASS::const_op_iterator CLASS::op_begin() const { \
|
|
return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
|
|
} \
|
|
CLASS::op_iterator CLASS::op_end() { \
|
|
return OperandTraits<CLASS>::op_end(this); \
|
|
} \
|
|
CLASS::const_op_iterator CLASS::op_end() const { \
|
|
return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
|
|
} \
|
|
VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
|
|
assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
|
|
&& "getOperand() out of range!"); \
|
|
return static_cast<VALUECLASS*>( \
|
|
OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture]); \
|
|
} \
|
|
void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
|
|
assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
|
|
&& "setOperand() out of range!"); \
|
|
OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
|
|
} \
|
|
unsigned CLASS::getNumOperands() const { \
|
|
return OperandTraits<CLASS>::operands(this); \
|
|
} \
|
|
template <int Idx_nocapture> Use &CLASS::Op() { \
|
|
return this->OpFrom<Idx_nocapture>(this); \
|
|
} \
|
|
template <int Idx_nocapture> const Use &CLASS::Op() const { \
|
|
return this->OpFrom<Idx_nocapture>(this); \
|
|
}
|
|
|
|
|
|
/// Macro for generating out-of-class operand accessor
|
|
/// definitions with casted result
|
|
#define DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
|
|
CLASS::op_iterator CLASS::op_begin() { \
|
|
return OperandTraits<CLASS>::op_begin(this); \
|
|
} \
|
|
CLASS::const_op_iterator CLASS::op_begin() const { \
|
|
return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
|
|
} \
|
|
CLASS::op_iterator CLASS::op_end() { \
|
|
return OperandTraits<CLASS>::op_end(this); \
|
|
} \
|
|
CLASS::const_op_iterator CLASS::op_end() const { \
|
|
return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
|
|
} \
|
|
VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
|
|
assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
|
|
&& "getOperand() out of range!"); \
|
|
return cast<VALUECLASS>( \
|
|
OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture]); \
|
|
} \
|
|
void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
|
|
assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
|
|
&& "setOperand() out of range!"); \
|
|
OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
|
|
} \
|
|
unsigned CLASS::getNumOperands() const { \
|
|
return OperandTraits<CLASS>::operands(this); \
|
|
} \
|
|
template <int Idx_nocapture> Use &CLASS::Op() { \
|
|
return this->OpFrom<Idx_nocapture>(this); \
|
|
} \
|
|
template <int Idx_nocapture> const Use &CLASS::Op() const { \
|
|
return this->OpFrom<Idx_nocapture>(this); \
|
|
}
|
|
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|