From 7d9e97c2ac6f47473b2cb34971c53db30e5e9c27 Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Mon, 17 Dec 2007 21:02:07 +0000 Subject: [PATCH] As per feedback, revised comments to (hopefully) make the different side effect flags clearer. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@45120 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Target/TargetInstrInfo.h | 37 +++++++++++++++++++-------- lib/Target/Target.td | 15 ++++++++--- 2 files changed, 38 insertions(+), 14 deletions(-) diff --git a/include/llvm/Target/TargetInstrInfo.h b/include/llvm/Target/TargetInstrInfo.h index e617e691ef6..28a08b28bfd 100644 --- a/include/llvm/Target/TargetInstrInfo.h +++ b/include/llvm/Target/TargetInstrInfo.h @@ -91,17 +91,23 @@ const unsigned M_NOT_DUPLICABLE = 1 << 16; // ARM instructions which can set condition code if 's' bit is set. const unsigned M_HAS_OPTIONAL_DEF = 1 << 17; -// M_MAY_HAVE_SIDE_EFFECTS - Set if this instruction *might* have side effects, -// e.g. load instructions. Note: This and M_NEVER_HAS_SIDE_EFFECTS are mutually -// exclusive. You can't set both! If neither flag is set, then the instruction -// *always* has side effects. -const unsigned M_MAY_HAVE_SIDE_EFFECTS = 1 << 18; - -// M_NEVER_HAS_SIDE_EFFECTS - Set if this instruction *never* has side effects, -// e.g., xor on X86. Note: This and M_MAY_HAVE_SIDE_EFFECTS are mutually -// exclusive. You can't set both! If neither flag is set, then the instruction -// *always* has side effects. -const unsigned M_NEVER_HAS_SIDE_EFFECTS = 1 << 19; +// M_NEVER_HAS_SIDE_EFFECTS - Set if this instruction has no side effects that +// are not captured by any operands of the instruction or other flags, and when +// *all* instances of the instruction of that opcode have no side effects. +// +// Note: This and M_MAY_HAVE_SIDE_EFFECTS are mutually exclusive. You can't set +// both! If neither flag is set, then the instruction *always* has side effects. +const unsigned M_NEVER_HAS_SIDE_EFFECTS = 1 << 18; + +// M_MAY_HAVE_SIDE_EFFECTS - Set if some instances of this instruction can have +// side effects. The virtual method "isReallySideEffectFree" is called to +// determine this. Load instructions are an example of where this is useful. In +// general, loads always have side effects. However, loads from constant pools +// don't. We let the specific back end make this determination. +// +// Note: This and M_NEVER_HAS_SIDE_EFFECTS are mutually exclusive. You can't set +// both! If neither flag is set, then the instruction *always* has side effects. +const unsigned M_MAY_HAVE_SIDE_EFFECTS = 1 << 19; // Machine operand flags // M_LOOK_UP_PTR_REG_CLASS - Set if this operand is a pointer value and it @@ -321,6 +327,15 @@ protected: return true; } + /// isReallySideEffectFree - If the M_MAY_HAVE_SIDE_EFFECTS flag is set, this + /// method is called to determine if the specific instance of this + /// instructions has side effects. This is useful in cases of instructions, + /// like loads, which generally always have side effects. A load from a + /// constant pool doesn't have side effects, though. So we need to + /// differentiate it from the general case. + virtual bool isReallySideEffectFree(MachineInstr *MI) const { + return false; + } public: /// getOperandConstraint - Returns the value of the specific constraint if /// it is set. Returns -1 if it is not set. diff --git a/lib/Target/Target.td b/lib/Target/Target.td index 9619cb98f9c..a9438a7a5e3 100644 --- a/lib/Target/Target.td +++ b/lib/Target/Target.td @@ -205,9 +205,18 @@ class Instruction { bit isNotDuplicable = 0; // Is it unsafe to duplicate this instruction? // Side effect flags - If neither of these flags is set, then the instruction - // *always* has side effects. Otherwise, it's one or the other. - bit mayHaveSideEffects = 0; // This instruction *may* have side effects. - bit neverHasSideEffects = 0; // This instruction never has side effects. + // *always* has side effects. When set, the flags have these meanings: + // + // neverHasSideEffects - The instruction has no side effects that are not + // captured by any operands of the instruction or other flags, and when + // *all* instances of the instruction of that opcode have no side effects. + // mayHaveSideEffects - Some instances of the instruction can have side + // effects. The virtual method "isReallySideEffectFree" is called to + // determine this. Load instructions are an example of where this is + // useful. In general, loads always have side effects. However, loads from + // constant pools don't. Individual back ends make this determination. + bit neverHasSideEffects = 0; + bit mayHaveSideEffects = 0; InstrItinClass Itinerary = NoItinerary;// Execution steps used for scheduling. -- 2.34.1