[JITLink][AArch32] Split out error test for invalid edge in applyFixup()

Also rename the fixture class since these tests are not ELF-specific.

Author: weliveindetail

llvm/unittests/ExecutionEngine/JITLink/AArch32ErrorTests.cpp

@@ -33,13 +33,14 @@ constexpr uint64_t AlignmentOffset = 0;
 constexpr orc::ExecutorAddrDiff SymbolOffset = 0;
 constexpr orc::ExecutorAddrDiff SymbolSize = 4;
 
-class AArch32Errors_ELF : public testing::Test {
+class AArch32Errors : public testing::Test {
 protected:
-  ArmConfig ArmCfg = getArmConfigForCPUArch(ARMBuildAttrs::v7);
+  const ArmConfig Cfg = getArmConfigForCPUArch(ARMBuildAttrs::v7);
   std::unique_ptr<LinkGraph> G;
   Section *S = nullptr;
 
   const uint8_t Zeros[4]{0x00, 0x00, 0x00, 0x00};
+  uint8_t MutableZeros[4]{0x00, 0x00, 0x00, 0x00};
 
 public:
   static void SetUpTestCase() {}
@@ -62,15 +63,24 @@ class AArch32Errors_ELF : public testing::Test {
     return G->createContentBlock(*S, CharContent, orc::ExecutorAddr(Addr),
                                  Alignment, AlignmentOffset);
   }
+
+  template <size_t Size>
+  Block &createMutableBlock(uint8_t (&Content)[Size], uint64_t Addr,
+                            uint64_t Alignment = 4) {
+    MutableArrayRef<char> CharContent{reinterpret_cast<char *>(&Content),
+                                      sizeof(Content)};
+    return G->createMutableContentBlock(
+        *S, CharContent, orc::ExecutorAddr(Addr), Alignment, AlignmentOffset);
+  }
 };
 
-TEST_F(AArch32Errors_ELF, readAddendDataErrors) {
+TEST_F(AArch32Errors, readAddendDataGeneric) {
   Block &ZerosBlock = createBlock(Zeros, 0x1000);
   constexpr uint64_t ZerosOffset = 0;
 
   // Invalid edge kind is the only error we can raise here right now.
   Edge::Kind Invalid = Edge::GenericEdgeKind::Invalid;
-  EXPECT_THAT_EXPECTED(readAddend(*G, ZerosBlock, ZerosOffset, Invalid, ArmCfg),
+  EXPECT_THAT_EXPECTED(readAddend(*G, ZerosBlock, ZerosOffset, Invalid, Cfg),
                        FailedWithMessage(testing::HasSubstr(
                            "can not read implicit addend for aarch32 edge kind "
                            "INVALID RELOCATION")));
@@ -121,6 +131,23 @@ TEST(AArch32_ELF, readAddendThumbErrors) {
   }
 }
 
+TEST_F(AArch32Errors, applyFixupDataGeneric) {
+  Block &OriginBlock = createMutableBlock(MutableZeros, 0x1000);
+  Block &TargetBlock = createBlock(Zeros, 0x2000);
+
+  constexpr uint64_t OffsetInTarget = 0;
+  Symbol &TargetSymbol = G->addAnonymousSymbol(TargetBlock, OffsetInTarget,
+                                               PointerSize, false, false);
+
+  constexpr uint64_t OffsetInOrigin = 0;
+  Edge::Kind Invalid = Edge::GenericEdgeKind::Invalid;
+  Edge InvalidEdge(Invalid, OffsetInOrigin, TargetSymbol, 0 /*Addend*/);
+  EXPECT_THAT_ERROR(
+      applyFixup(*G, OriginBlock, InvalidEdge, Cfg),
+      FailedWithMessage(testing::HasSubstr(
+          "encountered unfixable aarch32 edge kind INVALID RELOCATION")));
+}
+
 TEST(AArch32_ELF, applyFixupArmErrors) {
 
   constexpr orc::ExecutorAddr B3DummyAddr(0x5000);
@@ -134,13 +161,6 @@ TEST(AArch32_ELF, applyFixupArmErrors) {
 
   Symbol &TargetSymbol =
       G->addAnonymousSymbol(BArm, SymbolOffset, SymbolSize, false, false);
-  Edge InvalidEdge(Edge::GenericEdgeKind::Invalid, 0 /*Offset*/, TargetSymbol,
-                   0 /*Addend*/);
-
-  EXPECT_THAT_ERROR(
-      applyFixup(*G, BArm, InvalidEdge, ArmCfg),
-      FailedWithMessage(testing::HasSubstr(
-          "encountered unfixable aarch32 edge kind INVALID RELOCATION")));
 
   for (Edge::Kind K = FirstArmRelocation; K < LastArmRelocation; K += 1) {
     Edge E(K, 0, TargetSymbol, 0);
@@ -180,8 +200,6 @@ TEST(AArch32_ELF, applyFixupThumbErrors) {
       Sec, MutableThumbContent, B4DummyAddr, ThumbAlignment, AlignmentOffset);
   Symbol &TargetSymbol =
       G->addAnonymousSymbol(BThumb, SymbolOffset, SymbolSize, false, false);
-  Edge InvalidEdge(Edge::GenericEdgeKind::Invalid, 0 /*Offset*/, TargetSymbol,
-                   0 /*Addend*/);
 
   for (Edge::Kind K = FirstThumbRelocation; K < LastThumbRelocation; K += 1) {
     Edge E(K, 0, TargetSymbol, 0);