// code.
list<Predicate> Predicates = [];
+ // Code size.
+ int CodeSize = 0;
+
// Added complexity passed onto matching pattern.
int AddedComplexity = 0;
bit noResults = 0; // Does this instruction produce no results?
InstrItinClass Itinerary = NoItinerary;// Execution steps used for scheduling.
+
+ string Constraints = "";
+}
+
+/// Imp - Helper class for specifying the implicit uses/defs set for an
+/// instruction.
+class Imp<list<Register> uses, list<Register> defs> {
+ list<Register> Uses = uses;
+ list<Register> Defs = defs;
}
/// Predicates - These are extra conditionals which are turned into instruction
/// of operands.
def variable_ops;
+/// ptr_rc definition - Mark this operand as being a pointer value whose
+/// register class is resolved dynamically via a callback to TargetInstrInfo.
+/// FIXME: We should probably change this to a class which contain a list of
+/// flags. But currently we have but one flag.
+def ptr_rc;
+
/// Operand Types - These provide the built-in operand types that may be used
/// by a target. Targets can optionally provide their own operand types as
/// needed, though this should not be needed for RISC targets.
class Operand<ValueType ty> {
ValueType Type = ty;
string PrintMethod = "printOperand";
- int NumMIOperands = 1;
dag MIOperandInfo = (ops);
}
def i32imm : Operand<i32>;
def i64imm : Operand<i64>;
+
+/// PredicateOperand - This can be used to define a predicate operand for an
+/// instruction. OpTypes specifies the MIOperandInfo for the operand, and
+/// AlwaysVal specifies the value of this predicate when set to "always
+/// execute".
+class PredicateOperand<dag OpTypes, dag AlwaysVal> : Operand<OtherVT> {
+ let MIOperandInfo = OpTypes;
+ dag ExecuteAlways = AlwaysVal;
+}
+
+
// InstrInfo - This class should only be instantiated once to provide parameters
// which are global to the the target machine.
//