aboutsummaryrefslogtreecommitdiff
path: root/backend/lib/CodeGen
diff options
context:
space:
mode:
Diffstat (limited to 'backend/lib/CodeGen')
-rw-r--r--backend/lib/CodeGen/CMakeLists.txt4
-rw-r--r--backend/lib/CodeGen/MachineFunctionCloner.cpp4
-rw-r--r--backend/lib/CodeGen/MachineFunctionRecords.cpp187
-rw-r--r--backend/lib/CodeGen/MachineVerifier.cpp68
4 files changed, 263 insertions, 0 deletions
diff --git a/backend/lib/CodeGen/CMakeLists.txt b/backend/lib/CodeGen/CMakeLists.txt
index 35e9a23..3625473 100644
--- a/backend/lib/CodeGen/CMakeLists.txt
+++ b/backend/lib/CodeGen/CMakeLists.txt
@@ -23,6 +23,7 @@ set(
MachineRegisterInfo.cpp
MachineVerifier.cpp
MachineFunctionProperties.cpp
+ MachineFunctionRecords.cpp
Register.cpp
RegisterMask.cpp
TargetConstant.cpp
@@ -53,6 +54,7 @@ set(
"${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineRegisterInfo.h"
"${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineVerifier.h"
"${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineFunctionProperties.h"
+ "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineFunctionRecords.h"
"${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/Register.h"
"${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/RegisterMask.h"
"${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/StableID.h"
@@ -112,6 +114,7 @@ rcc_backend_register_format_files(
"${CMAKE_CURRENT_SOURCE_DIR}/MachineRegisterInfo.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/MachineVerifier.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/MachineFunctionProperties.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/MachineFunctionRecords.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/Register.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/RegisterMask.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/TargetConstant.cpp"
@@ -142,6 +145,7 @@ rcc_backend_register_tidy_files(
"${CMAKE_CURRENT_SOURCE_DIR}/MachineRegisterInfo.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/MachineVerifier.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/MachineFunctionProperties.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/MachineFunctionRecords.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/Register.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/RegisterMask.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/TargetConstant.cpp"
diff --git a/backend/lib/CodeGen/MachineFunctionCloner.cpp b/backend/lib/CodeGen/MachineFunctionCloner.cpp
index 971ef3c..aae74ff 100644
--- a/backend/lib/CodeGen/MachineFunctionCloner.cpp
+++ b/backend/lib/CodeGen/MachineFunctionCloner.cpp
@@ -616,6 +616,10 @@ Expected<MachineFunctionCloneResult> cloneMachineFunction(const MachineFunction
if (!CompilationStatus)
return std::unexpected(CompilationStatus.error());
Result.ClonedFunction->compilationStatus() = std::move(*CompilationStatus);
+ auto Records = Source.records().clone(CloneContext);
+ if (!Records)
+ return std::unexpected(Records.error());
+ Result.ClonedFunction->records() = std::move(*Records);
Result.ClonedFunction->properties() = Source.properties();
Result.ClonedFunction->attributes() = Source.attributes();
auto DestinationVerification = MachineVerifier::verify(*Result.ClonedFunction, Target);
diff --git a/backend/lib/CodeGen/MachineFunctionRecords.cpp b/backend/lib/CodeGen/MachineFunctionRecords.cpp
new file mode 100644
index 0000000..be0d936
--- /dev/null
+++ b/backend/lib/CodeGen/MachineFunctionRecords.cpp
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "rcc/CodeGen/MachineFunctionRecords.h"
+
+#include "rcc/CodeGen/MachineFunctionCloner.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+#include <unordered_set>
+#include <utility>
+
+namespace rcc {
+namespace {
+
+[[nodiscard]] Expected<void>
+verifyCalleeSavedRegisters(std::span<const PhysicalRegister> Registers) {
+ std::unordered_set<PhysicalRegister> Seen;
+ for (const PhysicalRegister Reg : Registers) {
+ if (!Reg.isValid()) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "callee-saved register list contains noreg");
+ }
+ if (!Seen.insert(Reg).second) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "callee-saved register list contains a duplicate register");
+ }
+ }
+ return {};
+}
+
+[[nodiscard]] Expected<void> verifyCallSite(const MachineCallSiteInfo &CallSite) {
+ if (!CallSite.CallInstruction.isValid()) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "call-site record has an invalid instruction StableID");
+ }
+ for (const MachineCallSiteArgument &Argument : CallSite.ForwardedArguments) {
+ if (!Argument.Reg.isValid()) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "call-site forwarded argument contains noreg");
+ }
+ }
+ return {};
+}
+
+[[nodiscard]] Expected<void> verifyCalledGlobal(const MachineCalledGlobal &CalledGlobal) {
+ if (!CalledGlobal.CallInstruction.isValid()) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "called-global record has an invalid instruction StableID");
+ }
+ if (CalledGlobal.Callee.empty()) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "called-global record has an empty callee name");
+ }
+ return {};
+}
+
+} // namespace
+
+Expected<void>
+MachineFunctionRecords::setCalleeSavedRegisters(std::vector<PhysicalRegister> Registers) {
+ auto Verification = verifyCalleeSavedRegisters(Registers);
+ if (!Verification)
+ return std::unexpected(Verification.error());
+ CalleeSavedRegisters = std::move(Registers);
+ return {};
+}
+
+Expected<void> MachineFunctionRecords::addCallSite(MachineCallSiteInfo CallSite) {
+ auto Verification = verifyCallSite(CallSite);
+ if (!Verification)
+ return std::unexpected(Verification.error());
+ if (std::ranges::any_of(CallSites, [&CallSite](const MachineCallSiteInfo &Existing) {
+ return Existing.CallInstruction == CallSite.CallInstruction;
+ })) {
+ return makeUnexpected(ErrorCode::InvalidArgument,
+ "call instruction already has a call-site record");
+ }
+ CallSites.push_back(std::move(CallSite));
+ return {};
+}
+
+Expected<void> MachineFunctionRecords::addCalledGlobal(MachineCalledGlobal CalledGlobal) {
+ auto Verification = verifyCalledGlobal(CalledGlobal);
+ if (!Verification)
+ return std::unexpected(Verification.error());
+ if (std::ranges::any_of(CalledGlobals, [&CalledGlobal](const MachineCalledGlobal &Existing) {
+ return Existing.CallInstruction == CalledGlobal.CallInstruction;
+ })) {
+ return makeUnexpected(ErrorCode::InvalidArgument,
+ "call instruction already has a called-global record");
+ }
+ CalledGlobals.push_back(std::move(CalledGlobal));
+ return {};
+}
+
+Expected<void> MachineFunctionRecords::addPrefetchTarget(MachinePrefetchTarget Target) {
+ if (std::ranges::find(PrefetchTargets, Target) != PrefetchTargets.end()) {
+ return makeUnexpected(ErrorCode::InvalidArgument, "prefetch target is already recorded");
+ }
+ PrefetchTargets.push_back(Target);
+ return {};
+}
+
+Expected<void> MachineFunctionRecords::verify() const {
+ if (CalleeSavedRegisters) {
+ auto CalleeSavedVerification = verifyCalleeSavedRegisters(*CalleeSavedRegisters);
+ if (!CalleeSavedVerification)
+ return CalleeSavedVerification;
+ }
+
+ std::unordered_set<MachineInstrStableID> CallInstructions;
+ for (const MachineCallSiteInfo &CallSite : CallSites) {
+ auto CallSiteVerification = verifyCallSite(CallSite);
+ if (!CallSiteVerification)
+ return CallSiteVerification;
+ if (!CallInstructions.insert(CallSite.CallInstruction).second) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "multiple call-site records reference one call instruction");
+ }
+ }
+
+ std::unordered_set<MachineInstrStableID> CalledGlobalInstructions;
+ for (const MachineCalledGlobal &CalledGlobal : CalledGlobals) {
+ auto CalledGlobalVerification = verifyCalledGlobal(CalledGlobal);
+ if (!CalledGlobalVerification)
+ return CalledGlobalVerification;
+ if (!CalledGlobalInstructions.insert(CalledGlobal.CallInstruction).second) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "multiple called-global records reference one call instruction");
+ }
+ }
+
+ for (std::size_t Index = 0; Index < PrefetchTargets.size(); ++Index) {
+ if (std::ranges::find(PrefetchTargets.begin() + static_cast<std::ptrdiff_t>(Index + 1),
+ PrefetchTargets.end(), PrefetchTargets[Index]) != PrefetchTargets.end()) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "prefetch target list contains a duplicate entry");
+ }
+ }
+ return {};
+}
+
+Expected<MachineFunctionRecords>
+MachineFunctionRecords::clone(const MachineFunctionCloneContext &CloneContext) const {
+ auto Verification = verify();
+ if (!Verification)
+ return std::unexpected(Verification.error());
+
+ MachineFunctionRecords Result;
+ if (CalleeSavedRegisters) {
+ auto SetResult = Result.setCalleeSavedRegisters(*CalleeSavedRegisters);
+ if (!SetResult)
+ return std::unexpected(SetResult.error());
+ }
+
+ for (const MachineCallSiteInfo &Source : CallSites) {
+ auto Instruction = CloneContext.mapInstructionStableID(Source.CallInstruction);
+ if (!Instruction)
+ return std::unexpected(Instruction.error());
+ MachineCallSiteInfo Destination = Source;
+ Destination.CallInstruction = *Instruction;
+ auto AddResult = Result.addCallSite(std::move(Destination));
+ if (!AddResult)
+ return std::unexpected(AddResult.error());
+ }
+
+ for (const MachineCalledGlobal &Source : CalledGlobals) {
+ auto Instruction = CloneContext.mapInstructionStableID(Source.CallInstruction);
+ if (!Instruction)
+ return std::unexpected(Instruction.error());
+ MachineCalledGlobal Destination = Source;
+ Destination.CallInstruction = *Instruction;
+ auto AddResult = Result.addCalledGlobal(std::move(Destination));
+ if (!AddResult)
+ return std::unexpected(AddResult.error());
+ }
+
+ for (const MachinePrefetchTarget Source : PrefetchTargets) {
+ auto AddResult = Result.addPrefetchTarget(Source);
+ if (!AddResult)
+ return std::unexpected(AddResult.error());
+ }
+ return Result;
+}
+
+} // namespace rcc
diff --git a/backend/lib/CodeGen/MachineVerifier.cpp b/backend/lib/CodeGen/MachineVerifier.cpp
index 905d685..d1c6989 100644
--- a/backend/lib/CodeGen/MachineVerifier.cpp
+++ b/backend/lib/CodeGen/MachineVerifier.cpp
@@ -54,6 +54,9 @@ public:
auto LayoutResult = verifyBlockLayout();
if (!LayoutResult)
return LayoutResult;
+ auto RecordResult = verifyFunctionRecords();
+ if (!RecordResult)
+ return RecordResult;
auto CompilationStatusResult = verifyCompilationStatus();
if (!CompilationStatusResult)
return CompilationStatusResult;
@@ -177,6 +180,12 @@ private:
if (Block->denseNumber() != LayoutIndex || Block->layoutIndex() != LayoutIndex) {
return fail("block dense number or layout index is stale");
}
+ if (const auto &ProfileID = Block->attributes().profileID()) {
+ const std::uint64_t Key = (static_cast<std::uint64_t>(ProfileID->BaseID) << 32U) |
+ static_cast<std::uint64_t>(ProfileID->CloneID);
+ if (!LinkedBlockProfileIDs.insert(Key).second)
+ return fail("multiple linked blocks have the same bb_id");
+ }
auto InstructionResult = verifyInstructionLayout(*Block);
if (!InstructionResult)
@@ -237,6 +246,7 @@ private:
if (!LinkedInstructions.insert(Instruction).second)
return fail("instruction layout contains a cycle or duplicate instruction");
LinkedInstructionIDs.insert(Instruction->stableID());
+ LinkedInstructionsByID.emplace(Instruction->stableID(), Instruction);
if (Instruction->parent() != &Block || Instruction->previous() != Previous) {
return fail("instruction parent or previous link is inconsistent");
}
@@ -333,6 +343,62 @@ private:
return {};
}
+ [[nodiscard]] Expected<void> verifyFunctionRecords() const {
+ const MachineFunctionRecords &Records = Function.records();
+ auto Verification = Records.verify();
+ if (!Verification)
+ return failWith("function records", Verification.error());
+
+ for (const PhysicalRegister Reg : Records.calleeSavedRegisters()) {
+ if (!Target.registers().isKnownPhysicalRegister(Reg))
+ return fail("callee-saved register list references an unknown physical register");
+ }
+
+ auto VerifyCall = [this](MachineInstrStableID ID,
+ std::string_view Kind) -> Expected<const MachineInstr *> {
+ const auto Position = LinkedInstructionsByID.find(ID);
+ if (Position == LinkedInstructionsByID.end()) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "machine function '" + std::string(Function.name()) +
+ "': " + std::string(Kind) +
+ " references a detached or unknown instruction");
+ }
+ const InstructionDescriptor *Descriptor =
+ Target.instructionDescriptor(Position->second->opcode());
+ if (Descriptor == nullptr || !Descriptor->Flags.has(InstructionFlag::Call)) {
+ return makeUnexpected(ErrorCode::VerificationError,
+ "machine function '" + std::string(Function.name()) +
+ "': " + std::string(Kind) + " references a non-call instruction");
+ }
+ return Position->second;
+ };
+
+ for (const MachineCallSiteInfo &CallSite : Records.callSites()) {
+ auto Call = VerifyCall(CallSite.CallInstruction, "call-site record");
+ if (!Call)
+ return std::unexpected(Call.error());
+ for (const MachineCallSiteArgument &Argument : CallSite.ForwardedArguments) {
+ if (!Target.registers().isKnownPhysicalRegister(Argument.Reg)) {
+ return fail("call-site record references an unknown forwarded physical register");
+ }
+ }
+ }
+
+ for (const MachineCalledGlobal &CalledGlobal : Records.calledGlobals()) {
+ auto Call = VerifyCall(CalledGlobal.CallInstruction, "called-global record");
+ if (!Call)
+ return std::unexpected(Call.error());
+ }
+
+ for (const MachinePrefetchTarget &Prefetch : Records.prefetchTargets()) {
+ const std::uint64_t Key = (static_cast<std::uint64_t>(Prefetch.Block.BaseID) << 32U) |
+ static_cast<std::uint64_t>(Prefetch.Block.CloneID);
+ if (!LinkedBlockProfileIDs.contains(Key))
+ return fail("prefetch target references an unknown bb_id");
+ }
+ return {};
+ }
+
[[nodiscard]] Expected<void> verifyCompilationStatus() const {
const MachineCompilationStatus &Status = Function.compilationStatus();
auto Verification = Status.verify();
@@ -596,6 +662,8 @@ private:
std::unordered_set<const MachineInstr *> RegisteredInstructions;
std::unordered_set<const MachineInstr *> LinkedInstructions;
std::unordered_set<MachineInstrStableID> LinkedInstructionIDs;
+ std::unordered_map<MachineInstrStableID, const MachineInstr *> LinkedInstructionsByID;
+ std::unordered_set<std::uint64_t> LinkedBlockProfileIDs;
std::unordered_set<const MachineMemOperand *> RegisteredMemOperands;
std::unordered_map<Register, std::size_t> VirtualDefCounts;
bool HasPhi = false;
generated by cgit v1.2.3 (git 2.46.0) at 2026-10-29 04:03:28 +0000