From cfdbcc469f9691bd9dce3b0b86982a63d86ca6b7 Mon Sep 17 00:00:00 2001 From: Richard-Qin-X Date: Sat, 1 Aug 2026 14:50:04 +0800 Subject: [CodeGen] Add target state and compilation status --- .../include/rcc/CodeGen/MachineCompilationStatus.h | 107 +++++++++++ backend/include/rcc/CodeGen/MachineFunction.h | 27 +++ .../include/rcc/CodeGen/MachineFunctionCloner.h | 45 +++++ backend/include/rcc/CodeGen/TargetFunctionState.h | 210 +++++++++++++++++++++ 4 files changed, 389 insertions(+) create mode 100644 backend/include/rcc/CodeGen/MachineCompilationStatus.h create mode 100644 backend/include/rcc/CodeGen/TargetFunctionState.h (limited to 'backend/include') 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 +#include +#include +#include + +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 Location; + + friend bool operator==(const MachineCompilationDiagnostic &Left, + const MachineCompilationDiagnostic &Right) = default; +}; + +struct MachineCompilationFailure final { + MachineCompilationDiagnostic Diagnostic; + std::optional FailurePass; + std::optional FailureInstruction; + std::optional FailureStage; + std::optional FailureRule; + std::optional Target; + std::optional 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 fail(MachineCompilationState NewState, + MachineCompilationFailure NewFailure); + [[nodiscard]] Expected verify() const; + [[nodiscard]] Expected + clone(const MachineFunctionCloneContext &CloneContext) const; + + friend bool operator==(const MachineCompilationStatus &Left, + const MachineCompilationStatus &Right) = default; + +private: + MachineCompilationState State = MachineCompilationState::Success; + std::optional Failure; +}; + +} // namespace rcc + +#endif // RCC_CODEGEN_MACHINECOMPILATIONSTATUS_H diff --git a/backend/include/rcc/CodeGen/MachineFunction.h b/backend/include/rcc/CodeGen/MachineFunction.h index 38d88f9..b687573 100644 --- a/backend/include/rcc/CodeGen/MachineFunction.h +++ b/backend/include/rcc/CodeGen/MachineFunction.h @@ -3,12 +3,14 @@ #ifndef RCC_CODEGEN_MACHINEFUNCTION_H #define RCC_CODEGEN_MACHINEFUNCTION_H +#include "rcc/CodeGen/MachineCompilationStatus.h" #include "rcc/CodeGen/MachineConstantPool.h" #include "rcc/CodeGen/MachineFrameInfo.h" #include "rcc/CodeGen/MachineFunctionProperties.h" #include "rcc/CodeGen/MachineJumpTableInfo.h" #include "rcc/CodeGen/MachineRegisterInfo.h" #include "rcc/CodeGen/StableID.h" +#include "rcc/CodeGen/TargetFunctionState.h" #include "rcc/Support/Error.h" #include @@ -87,6 +89,29 @@ public: return Properties; } + [[nodiscard]] const TargetFunctionState &targetState() const noexcept { + return TargetState; + } + + [[nodiscard]] Expected setTargetState(TargetFunctionState State); + + template [[nodiscard]] ValueT *getTargetInfo() noexcept { + return TargetState.getIf(); + } + + template + [[nodiscard]] const ValueT *getTargetInfo() const noexcept { + return TargetState.getIf(); + } + + [[nodiscard]] MachineCompilationStatus &compilationStatus() noexcept { + return CompilationStatus; + } + + [[nodiscard]] const MachineCompilationStatus &compilationStatus() const noexcept { + return CompilationStatus; + } + [[nodiscard]] Expected createBasicBlock(); [[nodiscard]] Expected createInstruction(Opcode InstructionOpcode); [[nodiscard]] Expected @@ -141,6 +166,8 @@ private: MachineConstantPool ConstantPool; MachineJumpTableInfo JumpTables; MachineFunctionProperties Properties; + TargetFunctionState TargetState; + MachineCompilationStatus CompilationStatus; MachineBasicBlock *FirstBlock = nullptr; MachineBasicBlock *LastBlock = nullptr; std::vector AllBlocks; diff --git a/backend/include/rcc/CodeGen/MachineFunctionCloner.h b/backend/include/rcc/CodeGen/MachineFunctionCloner.h index 3abdf78..658614f 100644 --- a/backend/include/rcc/CodeGen/MachineFunctionCloner.h +++ b/backend/include/rcc/CodeGen/MachineFunctionCloner.h @@ -16,7 +16,9 @@ namespace rcc { class InstructionSet; +class MachineBasicBlock; class MachineFunction; +class MachineInstr; struct MachineFunctionCloneOptions final { MachineFunctionStableID NewStableID; @@ -40,6 +42,49 @@ struct MachineFunctionCloneResult final { std::unordered_map JumpTableIndices; }; +class MachineFunctionCloneContext final { +public: + [[nodiscard]] const MachineFunction &sourceFunction() const noexcept { + return Source; + } + + [[nodiscard]] MachineFunction &destinationFunction() const noexcept { + return Destination; + } + + [[nodiscard]] Expected mapBlock(const MachineBasicBlock &SourceBlock) const; + [[nodiscard]] Expected + mapInstruction(const MachineInstr &SourceInstruction) const; + [[nodiscard]] Expected + mapBlockStableID(MachineBlockStableID SourceID) const; + [[nodiscard]] Expected + mapInstructionStableID(MachineInstrStableID SourceID) const; + [[nodiscard]] Expected mapRegister(Register SourceRegister) const; + [[nodiscard]] Expected mapFrameIndex(FrameIndex SourceIndex) const; + [[nodiscard]] Expected + mapConstantPoolIndex(ConstantPoolIndex SourceIndex) const; + [[nodiscard]] Expected mapJumpTableIndex(JumpTableIndex SourceIndex) const; + +private: + MachineFunctionCloneContext( + const MachineFunction &Source, MachineFunction &Destination, + const MachineFunctionCloneResult &Result, + const std::unordered_map &Blocks, + const std::unordered_map &Instructions) noexcept + : Source(Source), Destination(Destination), Result(Result), Blocks(Blocks), + Instructions(Instructions) {} + + const MachineFunction &Source; + MachineFunction &Destination; + const MachineFunctionCloneResult &Result; + const std::unordered_map &Blocks; + const std::unordered_map &Instructions; + + friend Expected + cloneMachineFunction(const MachineFunction &Source, const InstructionSet &Instructions, + MachineFunctionCloneOptions Options); +}; + [[nodiscard]] Expected cloneMachineFunction(const MachineFunction &Source, const InstructionSet &Instructions, MachineFunctionCloneOptions Options); diff --git a/backend/include/rcc/CodeGen/TargetFunctionState.h b/backend/include/rcc/CodeGen/TargetFunctionState.h new file mode 100644 index 0000000..b11c91b --- /dev/null +++ b/backend/include/rcc/CodeGen/TargetFunctionState.h @@ -0,0 +1,210 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +#ifndef RCC_CODEGEN_TARGETFUNCTIONSTATE_H +#define RCC_CODEGEN_TARGETFUNCTIONSTATE_H + +#include "rcc/CodeGen/MachineIRTypes.h" +#include "rcc/Support/Error.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace rcc { + +class MachineFunctionCloneContext; + +struct EncodedTargetFunctionState final { + TargetFunctionStateTypeID TypeID; + std::uint32_t Version = 0; + std::vector Payload; + + friend bool operator==(const EncodedTargetFunctionState &Left, + const EncodedTargetFunctionState &Right) = default; +}; + +template +concept TargetFunctionStateValue = + std::move_constructible && + requires(const ValueT &Value, const ValueT &Other, + const MachineFunctionCloneContext &CloneContext, std::uint32_t Version, + std::span Payload) { + { ValueT::stableTypeID() } -> std::same_as; + { ValueT::schemaVersion() } -> std::same_as; + { Value.verify() } -> std::same_as>; + { Value.clone(CloneContext) } -> std::same_as>; + { Value.print() } -> std::same_as; + { Value.encode() } -> std::same_as>>; + { Value == Other } -> std::convertible_to; + { ValueT::decode(Version, Payload) } -> std::same_as>; + }; + +class TargetFunctionState final { +public: + TargetFunctionState() = default; + TargetFunctionState(const TargetFunctionState &) = delete; + TargetFunctionState &operator=(const TargetFunctionState &) = delete; + TargetFunctionState(TargetFunctionState &&) noexcept; + TargetFunctionState &operator=(TargetFunctionState &&) noexcept; + ~TargetFunctionState(); + + template + [[nodiscard]] static Expected create(ValueT Value) { + if (ValueT::stableTypeID().value() == 0) { + return makeUnexpected(ErrorCode::InvalidArgument, + "target function state TypeID must be nonzero"); + } + if (ValueT::schemaVersion() == 0) { + return makeUnexpected(ErrorCode::InvalidArgument, + "target function state schema version must be nonzero"); + } + auto Verification = Value.verify(); + if (!Verification) + return std::unexpected(Verification.error()); + + std::unique_ptr NewStorage = std::make_unique>(std::move(Value)); + return TargetFunctionState(std::move(NewStorage)); + } + + template + [[nodiscard]] static Expected + decode(const EncodedTargetFunctionState &Encoded) { + if (Encoded.TypeID != ValueT::stableTypeID()) { + return makeUnexpected( + ErrorCode::ParseError, + "encoded target function state TypeID does not match its target schema"); + } + if (Encoded.Version == 0) { + return makeUnexpected(ErrorCode::ParseError, "target function state version must be nonzero"); + } + auto Value = ValueT::decode(Encoded.Version, Encoded.Payload); + if (!Value) + return std::unexpected(Value.error()); + return create(std::move(*Value)); + } + + [[nodiscard]] bool hasValue() const noexcept { + return Storage != nullptr; + } + + [[nodiscard]] std::optional typeID() const noexcept; + [[nodiscard]] std::optional schemaVersion() const noexcept; + [[nodiscard]] Expected verify() const; + [[nodiscard]] Expected + clone(const MachineFunctionCloneContext &CloneContext) const; + [[nodiscard]] Expected print() const; + [[nodiscard]] Expected encode() const; + [[nodiscard]] bool equals(const TargetFunctionState &Other) const noexcept; + + template [[nodiscard]] ValueT *getIf() noexcept { + if (!hasType()) + return nullptr; + return &static_cast *>(Storage.get())->value(); + } + + template [[nodiscard]] const ValueT *getIf() const noexcept { + if (!hasType()) + return nullptr; + return &static_cast *>(Storage.get())->value(); + } + +private: + class Concept { + public: + Concept() = default; + Concept(const Concept &) = delete; + Concept &operator=(const Concept &) = delete; + Concept(Concept &&) = delete; + Concept &operator=(Concept &&) = delete; + virtual ~Concept() = default; + + [[nodiscard]] virtual TargetFunctionStateTypeID typeID() const noexcept = 0; + [[nodiscard]] virtual std::uint32_t schemaVersion() const noexcept = 0; + [[nodiscard]] virtual const void *localTypeToken() const noexcept = 0; + [[nodiscard]] virtual Expected verify() const = 0; + [[nodiscard]] virtual Expected> + cloneStorage(const MachineFunctionCloneContext &CloneContext) const = 0; + [[nodiscard]] virtual std::string print() const = 0; + [[nodiscard]] virtual Expected> encodePayload() const = 0; + [[nodiscard]] virtual bool equals(const Concept &Other) const noexcept = 0; + }; + + template [[nodiscard]] static const void *typeToken() noexcept { + static const std::byte Token{}; + return &Token; + } + + template class Model final : public Concept { + public: + explicit Model(ValueT Value) : Value(std::move(Value)) {} + + [[nodiscard]] TargetFunctionStateTypeID typeID() const noexcept override { + return ValueT::stableTypeID(); + } + + [[nodiscard]] std::uint32_t schemaVersion() const noexcept override { + return ValueT::schemaVersion(); + } + + [[nodiscard]] const void *localTypeToken() const noexcept override { + return TargetFunctionState::typeToken(); + } + + [[nodiscard]] Expected verify() const override { + return Value.verify(); + } + + [[nodiscard]] Expected> + cloneStorage(const MachineFunctionCloneContext &CloneContext) const override { + auto Cloned = Value.clone(CloneContext); + if (!Cloned) + return std::unexpected(Cloned.error()); + std::unique_ptr Result = std::make_unique>(std::move(*Cloned)); + return Result; + } + + [[nodiscard]] std::string print() const override { + return Value.print(); + } + + [[nodiscard]] Expected> encodePayload() const override { + return Value.encode(); + } + + [[nodiscard]] bool equals(const Concept &Other) const noexcept override { + if (Other.localTypeToken() != TargetFunctionState::typeToken()) + return false; + return Value == static_cast &>(Other).Value; + } + + [[nodiscard]] ValueT &value() noexcept { + return Value; + } + + [[nodiscard]] const ValueT &value() const noexcept { + return Value; + } + + private: + ValueT Value; + }; + + explicit TargetFunctionState(std::unique_ptr Storage) : Storage(std::move(Storage)) {} + + template [[nodiscard]] bool hasType() const noexcept { + return Storage != nullptr && Storage->typeID() == ValueT::stableTypeID() && + Storage->localTypeToken() == typeToken(); + } + + std::unique_ptr Storage; +}; + +} // namespace rcc + +#endif // RCC_CODEGEN_TARGETFUNCTIONSTATE_H -- cgit v1.2.3