[MC] Implement RV64GC assembly emission

1 files changed, 42 insertions, 2 deletions

diff --git a/backend/unittests/CodeGen/CompilationUnitTest.cpp b/backend/unittests/CodeGen/CompilationUnitTest.cpp
index 39cd175..a31c9a8 100644
--- a/backend/unittests/CodeGen/CompilationUnitTest.cpp
+++ b/backend/unittests/CodeGen/CompilationUnitTest.cpp
@@ -4,6 +4,7 @@
 
 #include "rcc/CodeGen/MachineFunction.h"
 
+#include <cstddef>
 #include <iostream>
 #include <utility>
 
@@ -43,14 +44,53 @@ int main() {
   if (Unit.functionAt(2) != nullptr)
     return fail("CompilationUnit must reject an out-of-range ordered lookup");
 
+  auto Zero = rcc::GlobalInitializer::zeroFill(4);
+  if (!Zero)
+    return fail("Global initializer creation must succeed");
+  rcc::GlobalObjectDesc Object;
+  Object.Symbol = "global";
+  Object.ObjectType = rcc::GenericConstantType::byte();
+  Object.Size = 4;
+  Object.Initializer.emplace(std::move(*Zero));
+  auto Global = Unit.addGlobalObject(std::move(Object));
+  if (!Global || Unit.globalObjectCount() != 1 || Unit.globalObject("global") != *Global ||
+      Unit.globalObjectAt(0) != *Global || Unit.globalObjectAt(1) != nullptr)
+    return fail("CompilationUnit must own and index global objects");
+
+  auto ConflictingFunction = Unit.createMachineFunction("global");
+  if (ConflictingFunction || Unit.functionCount() != 2)
+    return fail("CompilationUnit must reject function/global symbol conflicts atomically");
+
+  rcc::GlobalObjectDesc ConflictingGlobal;
+  ConflictingGlobal.Symbol = "first";
+  ConflictingGlobal.ObjectType = rcc::GenericConstantType::byte();
+  ConflictingGlobal.Size = 1;
+  auto Byte = rcc::GlobalInitializer::bytes({std::byte{1}});
+  if (!Byte)
+    return fail("Byte initializer creation must succeed");
+  ConflictingGlobal.Initializer.emplace(std::move(*Byte));
+  if (Unit.addGlobalObject(std::move(ConflictingGlobal)) || Unit.globalObjectCount() != 1)
+    return fail("CompilationUnit must reject global/function symbol conflicts atomically");
+
+  auto MismatchedBytes = rcc::GlobalInitializer::bytes({std::byte{1}, std::byte{2}});
+  if (!MismatchedBytes)
+    return fail("Mismatched initializer construction must succeed before object verification");
+  rcc::GlobalObjectDesc MismatchedObject;
+  MismatchedObject.Symbol = "mismatched";
+  MismatchedObject.ObjectType = rcc::GenericConstantType::byte();
+  MismatchedObject.Size = 1;
+  MismatchedObject.Initializer.emplace(std::move(*MismatchedBytes));
+  if (Unit.addGlobalObject(std::move(MismatchedObject)) || Unit.globalObjectCount() != 1)
+    return fail("CompilationUnit must reject mismatched global initializer sizes atomically");
+
   auto Verification = Unit.verify();
   if (!Verification)
     return fail("A valid CompilationUnit must pass verification");
 
   rcc::CompilationUnit Moved = std::move(Unit);
   if (Moved.functionCount() != 2 || Moved.function("first") != *First ||
-      Moved.function("second") != *Second)
-    return fail("Moving a CompilationUnit must preserve owned function addresses and indices");
+      Moved.function("second") != *Second || Moved.globalObject("global") != *Global)
+    return fail("Moving a CompilationUnit must preserve owned object addresses and indices");
   Verification = Moved.verify();
   if (!Verification)
     return fail("A moved CompilationUnit must pass verification");