[GlobalISel] Propagate no-fp-except flags

3 files changed, 62 insertions, 0 deletions

diff --git a/backend/include/rcc/CodeGen/GlobalISel/InstructionSelector.h b/backend/include/rcc/CodeGen/GlobalISel/InstructionSelector.h
index 4c69606..4bea4e7 100644
--- a/backend/include/rcc/CodeGen/GlobalISel/InstructionSelector.h
+++ b/backend/include/rcc/CodeGen/GlobalISel/InstructionSelector.h
@@ -3,6 +3,7 @@
 #ifndef RCC_CODEGEN_GLOBALISEL_INSTRUCTIONSELECTOR_H
 #define RCC_CODEGEN_GLOBALISEL_INSTRUCTIONSELECTOR_H
 
+#include "rcc/CodeGen/MachineIRTypes.h"
 #include "rcc/Support/Error.h"
 
 namespace rcc {
@@ -28,6 +29,15 @@ public:
   constrainSelectedInstruction(MachineInstr &, MachineFunction &, const TargetDescription &) const {
     return {};
   }
+
+  [[nodiscard]] Expected<void> propagateSelectionFlags(MachineInstr &Output,
+                                                       MachineInstrFlags InputFlags,
+                                                       bool InputMayRaiseFPException,
+                                                       const TargetDescription &Target) const;
+
+  [[nodiscard]] Expected<void> propagateSelectionFlags(MachineInstr &Output,
+                                                       const MachineInstr &Input,
+                                                       const TargetDescription &Target) const;
 };
 
 } // namespace rcc
diff --git a/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp b/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp
index 862b63f..1f7f453 100644
--- a/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp
+++ b/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp
@@ -169,6 +169,36 @@ void combineFingerprint(std::uint64_t &State, std::uint64_t Value) noexcept {
 
 } // namespace
 
+Expected<void> InstructionSelector::propagateSelectionFlags(MachineInstr &Output,
+                                                            MachineInstrFlags InputFlags,
+                                                            bool InputMayRaiseFPException,
+                                                            const TargetDescription &Target) const {
+  const InstructionDescriptor *OutputDescriptor = Target.instructionDescriptor(Output.opcode());
+  if (OutputDescriptor == nullptr) {
+    return makeUnexpected(ErrorCode::VerificationError,
+                          "instruction selector produced an unknown instruction descriptor");
+  }
+  if (!InputMayRaiseFPException &&
+      OutputDescriptor->Flags.has(InstructionFlag::MayRaiseFPException)) {
+    InputFlags.set(MachineInstrFlag::NoFPExcept);
+  }
+  Output.setFlags(InputFlags);
+  return {};
+}
+
+Expected<void> InstructionSelector::propagateSelectionFlags(MachineInstr &Output,
+                                                            const MachineInstr &Input,
+                                                            const TargetDescription &Target) const {
+  const InstructionDescriptor *InputDescriptor = Target.instructionDescriptor(Input.opcode());
+  if (InputDescriptor == nullptr) {
+    return makeUnexpected(ErrorCode::VerificationError,
+                          "instruction selector input has an unknown instruction descriptor");
+  }
+  return propagateSelectionFlags(Output, Input.flags(),
+                                 InputDescriptor->Flags.has(InstructionFlag::MayRaiseFPException),
+                                 Target);
+}
+
 const MachinePassContract &InstructionSelect::contract() const noexcept {
   return instructionSelectContract();
 }
@@ -272,6 +302,9 @@ Expected<MachinePassResult> InstructionSelect::runImplementation(MachineFunction
                                              CurrentDescriptor->Name + "'",
                                          ErrorCode::VerificationError));
     }
+    const MachineInstrFlags InputFlags = Instruction->flags();
+    const bool InputMayRaiseFPException =
+        CurrentDescriptor->Flags.has(InstructionFlag::MayRaiseFPException);
     auto Selection = Info->select(*Instruction, Function, Target);
     if (!Selection)
       return std::unexpected(Selection.error());
@@ -279,6 +312,10 @@ Expected<MachinePassResult> InstructionSelect::runImplementation(MachineFunction
     if (Selected == nullptr)
       return std::unexpected(
           passFailure("instruction selector produced an unknown instruction descriptor"));
+    auto FlagPropagation =
+        Info->propagateSelectionFlags(*Instruction, InputFlags, InputMayRaiseFPException, Target);
+    if (!FlagPropagation)
+      return std::unexpected(FlagPropagation.error());
     auto Constraint = Info->constrainSelectedInstruction(*Instruction, Function, Target);
     if (!Constraint) {
       return std::unexpected(withErrorContext(
diff --git a/backend/lib/Target/RISCV/GISel/RISCVInstructionSelector.cpp b/backend/lib/Target/RISCV/GISel/RISCVInstructionSelector.cpp
index 099de83..62c10af 100644
--- a/backend/lib/Target/RISCV/GISel/RISCVInstructionSelector.cpp
+++ b/backend/lib/Target/RISCV/GISel/RISCVInstructionSelector.cpp
@@ -660,6 +660,9 @@ private:
     auto Built = Pending->build();
     if (!Built)
       return std::unexpected(Built.error());
+    auto FlagPropagation = propagateSelectionFlags(**Built, Anchor, Builder.target());
+    if (!FlagPropagation)
+      return std::unexpected(FlagPropagation.error());
     auto Constraint = constrainSelectedInstruction(**Built, Builder.function(), Builder.target());
     if (!Constraint)
       return std::unexpected(Constraint.error());
@@ -691,6 +694,9 @@ private:
     auto Built = Pending->build();
     if (!Built)
       return std::unexpected(Built.error());
+    auto FlagPropagation = propagateSelectionFlags(**Built, Anchor, Builder.target());
+    if (!FlagPropagation)
+      return std::unexpected(FlagPropagation.error());
     auto Constraint = constrainSelectedInstruction(**Built, Builder.function(), Builder.target());
     if (!Constraint)
       return std::unexpected(Constraint.error());
@@ -719,6 +725,9 @@ private:
     auto Built = Pending->build();
     if (!Built)
       return std::unexpected(Built.error());
+    auto FlagPropagation = propagateSelectionFlags(**Built, Anchor, Builder.target());
+    if (!FlagPropagation)
+      return std::unexpected(FlagPropagation.error());
     auto Constraint = constrainSelectedInstruction(**Built, Builder.function(), Builder.target());
     if (!Constraint)
       return std::unexpected(Constraint.error());
@@ -750,6 +759,9 @@ private:
     auto Built = Pending->build();
     if (!Built)
       return std::unexpected(Built.error());
+    auto FlagPropagation = propagateSelectionFlags(**Built, Anchor, Builder.target());
+    if (!FlagPropagation)
+      return std::unexpected(FlagPropagation.error());
     auto Constraint = constrainSelectedInstruction(**Built, Builder.function(), Builder.target());
     if (!Constraint)
       return std::unexpected(Constraint.error());
@@ -823,6 +835,9 @@ private:
     auto Built = Pending->build();
     if (!Built)
       return std::unexpected(Built.error());
+    auto FlagPropagation = propagateSelectionFlags(**Built, Anchor, Builder.target());
+    if (!FlagPropagation)
+      return std::unexpected(FlagPropagation.error());
     auto Constraint = constrainSelectedInstruction(**Built, Builder.function(), Builder.target());
     if (!Constraint)
       return std::unexpected(Constraint.error());