[CodeGen] Add target state and compilation status

1 files changed, 107 insertions, 0 deletions

diff --git a/backend/include/rcc/CodeGen/MachineCompilationStatus.h b/backend/include/rcc/CodeGen/MachineCompilationStatus.h
new file mode 100644
index 0000000..f889574
--- /dev/null
+++ b/backend/include/rcc/CodeGen/MachineCompilationStatus.h
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef RCC_CODEGEN_MACHINECOMPILATIONSTATUS_H
+#define RCC_CODEGEN_MACHINECOMPILATIONSTATUS_H
+
+#include "rcc/CodeGen/InstructionDescriptor.h"
+#include "rcc/CodeGen/MachineIRTypes.h"
+#include "rcc/CodeGen/StableID.h"
+#include "rcc/Support/Error.h"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <string_view>
+
+namespace rcc {
+
+class MachineFunctionCloneContext;
+
+enum class MachineCompilationState : std::uint8_t {
+  Success,
+  Unsupported,
+  MIRParseFailed,
+  LegalizationFailed,
+  SelectionFailed,
+  RegisterAllocationFailed,
+  CallLoweringFailed,
+  FrameLayoutFailed,
+  FinalizationFailed,
+  AssemblyLoweringFailed,
+  InternalError,
+  Count,
+};
+
+[[nodiscard]] bool isKnownMachineCompilationState(MachineCompilationState State) noexcept;
+[[nodiscard]] std::string_view
+getMachineCompilationStateName(MachineCompilationState State) noexcept;
+
+enum class MachineCompilationDiagnosticSeverity : std::uint8_t {
+  Error,
+  Fatal,
+  Count,
+};
+
+struct MachineCompilationDiagnostic final {
+  MachineCompilationDiagnosticSeverity Severity = MachineCompilationDiagnosticSeverity::Error;
+  ErrorCode Code = ErrorCode::InternalError;
+  std::string Message;
+  std::optional<SourceLocation> Location;
+
+  friend bool operator==(const MachineCompilationDiagnostic &Left,
+                         const MachineCompilationDiagnostic &Right) = default;
+};
+
+struct MachineCompilationFailure final {
+  MachineCompilationDiagnostic Diagnostic;
+  std::optional<std::string> FailurePass;
+  std::optional<MachineInstrStableID> FailureInstruction;
+  std::optional<PipelineStage> FailureStage;
+  std::optional<std::string> FailureRule;
+  std::optional<std::string> Target;
+  std::optional<std::string> Subtarget;
+
+  friend bool operator==(const MachineCompilationFailure &Left,
+                         const MachineCompilationFailure &Right) = default;
+};
+
+class MachineCompilationStatus final {
+public:
+  MachineCompilationStatus() = default;
+  MachineCompilationStatus(const MachineCompilationStatus &) = delete;
+  MachineCompilationStatus &operator=(const MachineCompilationStatus &) = delete;
+  MachineCompilationStatus(MachineCompilationStatus &&) noexcept = default;
+  MachineCompilationStatus &operator=(MachineCompilationStatus &&) noexcept = default;
+  ~MachineCompilationStatus() = default;
+
+  [[nodiscard]] MachineCompilationState state() const noexcept {
+    return State;
+  }
+
+  [[nodiscard]] bool succeeded() const noexcept {
+    return State == MachineCompilationState::Success;
+  }
+
+  [[nodiscard]] const MachineCompilationFailure *failure() const noexcept {
+    if (!Failure)
+      return nullptr;
+    return &*Failure;
+  }
+
+  [[nodiscard]] Expected<void> fail(MachineCompilationState NewState,
+                                    MachineCompilationFailure NewFailure);
+  [[nodiscard]] Expected<void> verify() const;
+  [[nodiscard]] Expected<MachineCompilationStatus>
+  clone(const MachineFunctionCloneContext &CloneContext) const;
+
+  friend bool operator==(const MachineCompilationStatus &Left,
+                         const MachineCompilationStatus &Right) = default;
+
+private:
+  MachineCompilationState State = MachineCompilationState::Success;
+  std::optional<MachineCompilationFailure> Failure;
+};
+
+} // namespace rcc
+
+#endif // RCC_CODEGEN_MACHINECOMPILATIONSTATUS_H