llvm/unittests/Target/AArch64/SMEAttributesTest.cpp

   1 #include "Utils/AArch64SMEAttributes.h"
   2 #include "llvm/AsmParser/Parser.h"
   3 #include "llvm/IR/Function.h"
   4 #include "llvm/IR/Module.h"
   5 #include "llvm/Support/SourceMgr.h"
   6
   7 #include "gtest/gtest.h"
   8
   9 using namespace llvm;
  10 using SA = SMEAttrs;
  11
  12 std::unique_ptr<Module> parseIR(const char *IR) {
  13   static LLVMContext C;
  14   SMDiagnostic Err;
  15   return parseAssemblyString(IR, Err, C);
  16 }
  17
  18 TEST(SMEAttributes, Constructors) {
  19   LLVMContext Context;
  20
  21   ASSERT_TRUE(SA(*parseIR("declare void @foo()")->getFunction("foo"))
  22                   .hasNonStreamingInterfaceAndBody());
  23
  24   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_pstate_sm_body\"")
  25                       ->getFunction("foo"))
  26                   .hasNonStreamingInterface());
  27
  28   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_pstate_sm_enabled\"")
  29                       ->getFunction("foo"))
  30                   .hasStreamingInterface());
  31
  32   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_pstate_sm_body\"")
  33                       ->getFunction("foo"))
  34                   .hasStreamingBody());
  35
  36   ASSERT_TRUE(
  37       SA(*parseIR("declare void @foo() \"aarch64_pstate_sm_compatible\"")
  38               ->getFunction("foo"))
  39           .hasStreamingCompatibleInterface());
  40
  41   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_pstate_za_shared\"")
  42                       ->getFunction("foo"))
  43                   .sharesZA());
  44
  45   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_pstate_za_shared\"")
  46                       ->getFunction("foo"))
  47                   .hasSharedZAInterface());
  48
  49   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_pstate_za_new\"")
  50                       ->getFunction("foo"))
  51                   .hasNewZABody());
  52
  53   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_pstate_za_preserved\"")
  54                       ->getFunction("foo"))
  55                   .preservesZA());
  56
  57   ASSERT_TRUE(
  58       SA(*parseIR("declare void @foo() \"aarch64_in_zt0\"")->getFunction("foo"))
  59           .isInZT0());
  60   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_out_zt0\"")
  61                       ->getFunction("foo"))
  62                   .isOutZT0());
  63   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_inout_zt0\"")
  64                       ->getFunction("foo"))
  65                   .isInOutZT0());
  66   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_preserves_zt0\"")
  67                       ->getFunction("foo"))
  68                   .isPreservesZT0());
  69   ASSERT_TRUE(SA(*parseIR("declare void @foo() \"aarch64_new_zt0\"")
  70                       ->getFunction("foo"))
  71                   .isNewZT0());
  72
  73   // Invalid combinations.
  74   EXPECT_DEBUG_DEATH(SA(SA::SM_Enabled | SA::SM_Compatible),
  75                      "SM_Enabled and SM_Compatible are mutually exclusive");
  76   EXPECT_DEBUG_DEATH(SA(SA::ZA_New | SA::ZA_Shared),
  77                      "ZA_New and ZA_Shared are mutually exclusive");
  78   EXPECT_DEBUG_DEATH(SA(SA::ZA_New | SA::ZA_Preserved),
  79                      "ZA_New and ZA_Preserved are mutually exclusive");
  80
  81   // Test that the set() methods equally check validity.
  82   EXPECT_DEBUG_DEATH(SA(SA::SM_Enabled).set(SA::SM_Compatible),
  83                      "SM_Enabled and SM_Compatible are mutually exclusive");
  84   EXPECT_DEBUG_DEATH(SA(SA::SM_Compatible).set(SA::SM_Enabled),
  85                      "SM_Enabled and SM_Compatible are mutually exclusive");
  86 }
  87
  88 TEST(SMEAttributes, Basics) {
  89   // Test PSTATE.SM interfaces.
  90   ASSERT_TRUE(SA(SA::Normal).hasNonStreamingInterfaceAndBody());
  91   ASSERT_TRUE(SA(SA::SM_Enabled).hasStreamingInterface());
  92   ASSERT_TRUE(SA(SA::SM_Body).hasStreamingBody());
  93   ASSERT_TRUE(SA(SA::SM_Body).hasNonStreamingInterface());
  94   ASSERT_FALSE(SA(SA::SM_Body).hasNonStreamingInterfaceAndBody());
  95   ASSERT_FALSE(SA(SA::SM_Body).hasStreamingInterface());
  96   ASSERT_TRUE(SA(SA::SM_Compatible).hasStreamingCompatibleInterface());
  97   ASSERT_TRUE(
  98       SA(SA::SM_Compatible | SA::SM_Body).hasStreamingCompatibleInterface());
  99   ASSERT_TRUE(SA(SA::SM_Compatible | SA::SM_Body).hasStreamingBody());
 100   ASSERT_FALSE(SA(SA::SM_Compatible | SA::SM_Body).hasNonStreamingInterface());
 101
 102   // Test PSTATE.ZA interfaces.
 103   ASSERT_FALSE(SA(SA::ZA_Shared).hasPrivateZAInterface());
 104   ASSERT_TRUE(SA(SA::ZA_Shared).hasSharedZAInterface());
 105   ASSERT_TRUE(SA(SA::ZA_Shared).sharesZA());
 106   ASSERT_TRUE(SA(SA::ZA_Shared).hasZAState());
 107   ASSERT_FALSE(SA(SA::ZA_Shared).preservesZA());
 108   ASSERT_TRUE(SA(SA::ZA_Shared | SA::ZA_Preserved).preservesZA());
 109   ASSERT_FALSE(SA(SA::ZA_Shared).sharesZT0());
 110   ASSERT_FALSE(SA(SA::ZA_Shared).hasZT0State());
 111
 112   ASSERT_TRUE(SA(SA::ZA_New).hasPrivateZAInterface());
 113   ASSERT_FALSE(SA(SA::ZA_New).hasSharedZAInterface());
 114   ASSERT_TRUE(SA(SA::ZA_New).hasNewZABody());
 115   ASSERT_TRUE(SA(SA::ZA_New).hasZAState());
 116   ASSERT_FALSE(SA(SA::ZA_New).preservesZA());
 117   ASSERT_FALSE(SA(SA::ZA_New).sharesZT0());
 118   ASSERT_FALSE(SA(SA::ZA_New).hasZT0State());
 119
 120   ASSERT_TRUE(SA(SA::Normal).hasPrivateZAInterface());
 121   ASSERT_FALSE(SA(SA::Normal).hasSharedZAInterface());
 122   ASSERT_FALSE(SA(SA::Normal).hasNewZABody());
 123   ASSERT_FALSE(SA(SA::Normal).hasZAState());
 124   ASSERT_FALSE(SA(SA::Normal).preservesZA());
 125
 126   // Test ZT0 State interfaces
 127   SA ZT0_In = SA(SA::encodeZT0State(SA::StateValue::In));
 128   ASSERT_TRUE(ZT0_In.isInZT0());
 129   ASSERT_FALSE(ZT0_In.isOutZT0());
 130   ASSERT_FALSE(ZT0_In.isInOutZT0());
 131   ASSERT_FALSE(ZT0_In.isPreservesZT0());
 132   ASSERT_FALSE(ZT0_In.isNewZT0());
 133   ASSERT_TRUE(ZT0_In.sharesZT0());
 134   ASSERT_TRUE(ZT0_In.hasZT0State());
 135   ASSERT_TRUE(ZT0_In.hasSharedZAInterface());
 136   ASSERT_FALSE(ZT0_In.hasPrivateZAInterface());
 137
 138   SA ZT0_Out = SA(SA::encodeZT0State(SA::StateValue::Out));
 139   ASSERT_TRUE(ZT0_Out.isOutZT0());
 140   ASSERT_FALSE(ZT0_Out.isInZT0());
 141   ASSERT_FALSE(ZT0_Out.isInOutZT0());
 142   ASSERT_FALSE(ZT0_Out.isPreservesZT0());
 143   ASSERT_FALSE(ZT0_Out.isNewZT0());
 144   ASSERT_TRUE(ZT0_Out.sharesZT0());
 145   ASSERT_TRUE(ZT0_Out.hasZT0State());
 146   ASSERT_TRUE(ZT0_Out.hasSharedZAInterface());
 147   ASSERT_FALSE(ZT0_Out.hasPrivateZAInterface());
 148
 149   SA ZT0_InOut = SA(SA::encodeZT0State(SA::StateValue::InOut));
 150   ASSERT_TRUE(ZT0_InOut.isInOutZT0());
 151   ASSERT_FALSE(ZT0_InOut.isInZT0());
 152   ASSERT_FALSE(ZT0_InOut.isOutZT0());
 153   ASSERT_FALSE(ZT0_InOut.isPreservesZT0());
 154   ASSERT_FALSE(ZT0_InOut.isNewZT0());
 155   ASSERT_TRUE(ZT0_InOut.sharesZT0());
 156   ASSERT_TRUE(ZT0_InOut.hasZT0State());
 157   ASSERT_TRUE(ZT0_InOut.hasSharedZAInterface());
 158   ASSERT_FALSE(ZT0_InOut.hasPrivateZAInterface());
 159
 160   SA ZT0_Preserved = SA(SA::encodeZT0State(SA::StateValue::Preserved));
 161   ASSERT_TRUE(ZT0_Preserved.isPreservesZT0());
 162   ASSERT_FALSE(ZT0_Preserved.isInZT0());
 163   ASSERT_FALSE(ZT0_Preserved.isOutZT0());
 164   ASSERT_FALSE(ZT0_Preserved.isInOutZT0());
 165   ASSERT_FALSE(ZT0_Preserved.isNewZT0());
 166   ASSERT_TRUE(ZT0_Preserved.sharesZT0());
 167   ASSERT_TRUE(ZT0_Preserved.hasZT0State());
 168   ASSERT_TRUE(ZT0_Preserved.hasSharedZAInterface());
 169   ASSERT_FALSE(ZT0_Preserved.hasPrivateZAInterface());
 170
 171   SA ZT0_New = SA(SA::encodeZT0State(SA::StateValue::New));
 172   ASSERT_TRUE(ZT0_New.isNewZT0());
 173   ASSERT_FALSE(ZT0_New.isInZT0());
 174   ASSERT_FALSE(ZT0_New.isOutZT0());
 175   ASSERT_FALSE(ZT0_New.isInOutZT0());
 176   ASSERT_FALSE(ZT0_New.isPreservesZT0());
 177   ASSERT_FALSE(ZT0_New.sharesZT0());
 178   ASSERT_TRUE(ZT0_New.hasZT0State());
 179   ASSERT_FALSE(ZT0_New.hasSharedZAInterface());
 180   ASSERT_TRUE(ZT0_New.hasPrivateZAInterface());
 181
 182   ASSERT_FALSE(SA(SA::Normal).isInZT0());
 183   ASSERT_FALSE(SA(SA::Normal).isOutZT0());
 184   ASSERT_FALSE(SA(SA::Normal).isInOutZT0());
 185   ASSERT_FALSE(SA(SA::Normal).isPreservesZT0());
 186   ASSERT_FALSE(SA(SA::Normal).isNewZT0());
 187   ASSERT_FALSE(SA(SA::Normal).sharesZT0());
 188   ASSERT_FALSE(SA(SA::Normal).hasZT0State());
 189 }
 190
 191 TEST(SMEAttributes, Transitions) {
 192   // Normal -> Normal
 193   ASSERT_FALSE(SA(SA::Normal).requiresSMChange(SA(SA::Normal)));
 194   ASSERT_FALSE(SA(SA::Normal).requiresPreservingZT0(SA(SA::Normal)));
 195   ASSERT_FALSE(SA(SA::Normal).requiresDisablingZABeforeCall(SA(SA::Normal)));
 196   ASSERT_FALSE(SA(SA::Normal).requiresEnablingZAAfterCall(SA(SA::Normal)));
 197   // Normal -> Normal + LocallyStreaming
 198   ASSERT_FALSE(SA(SA::Normal).requiresSMChange(SA(SA::Normal | SA::SM_Body)));
 199
 200   // Normal -> Streaming
 201   ASSERT_TRUE(SA(SA::Normal).requiresSMChange(SA(SA::SM_Enabled)));
 202   // Normal -> Streaming + LocallyStreaming
 203   ASSERT_TRUE(
 204       SA(SA::Normal).requiresSMChange(SA(SA::SM_Enabled | SA::SM_Body)));
 205
 206   // Normal -> Streaming-compatible
 207   ASSERT_FALSE(SA(SA::Normal).requiresSMChange(SA(SA::SM_Compatible)));
 208   // Normal -> Streaming-compatible + LocallyStreaming
 209   ASSERT_FALSE(
 210       SA(SA::Normal).requiresSMChange(SA(SA::SM_Compatible | SA::SM_Body)));
 211
 212   // Streaming -> Normal
 213   ASSERT_TRUE(SA(SA::SM_Enabled).requiresSMChange(SA(SA::Normal)));
 214   // Streaming -> Normal + LocallyStreaming
 215   ASSERT_TRUE(
 216       SA(SA::SM_Enabled).requiresSMChange(SA(SA::Normal | SA::SM_Body)));
 217
 218   // Streaming -> Streaming
 219   ASSERT_FALSE(SA(SA::SM_Enabled).requiresSMChange(SA(SA::SM_Enabled)));
 220   // Streaming -> Streaming + LocallyStreaming
 221   ASSERT_FALSE(
 222       SA(SA::SM_Enabled).requiresSMChange(SA(SA::SM_Enabled | SA::SM_Body)));
 223
 224   // Streaming -> Streaming-compatible
 225   ASSERT_FALSE(SA(SA::SM_Enabled).requiresSMChange(SA(SA::SM_Compatible)));
 226   // Streaming -> Streaming-compatible + LocallyStreaming
 227   ASSERT_FALSE(
 228       SA(SA::SM_Enabled).requiresSMChange(SA(SA::SM_Compatible | SA::SM_Body)));
 229
 230   // Streaming-compatible -> Normal
 231   ASSERT_TRUE(SA(SA::SM_Compatible).requiresSMChange(SA(SA::Normal)));
 232   ASSERT_TRUE(
 233       SA(SA::SM_Compatible).requiresSMChange(SA(SA::Normal | SA::SM_Body)));
 234
 235   // Streaming-compatible -> Streaming
 236   ASSERT_TRUE(SA(SA::SM_Compatible).requiresSMChange(SA(SA::SM_Enabled)));
 237   // Streaming-compatible -> Streaming + LocallyStreaming
 238   ASSERT_TRUE(
 239       SA(SA::SM_Compatible).requiresSMChange(SA(SA::SM_Enabled | SA::SM_Body)));
 240
 241   // Streaming-compatible -> Streaming-compatible
 242   ASSERT_FALSE(SA(SA::SM_Compatible).requiresSMChange(SA(SA::SM_Compatible)));
 243   // Streaming-compatible -> Streaming-compatible + LocallyStreaming
 244   ASSERT_FALSE(SA(SA::SM_Compatible)
 245                    .requiresSMChange(SA(SA::SM_Compatible | SA::SM_Body)));
 246
 247   SA Private_ZA = SA(SA::Normal);
 248   SA ZA_Shared = SA(SA::ZA_Shared);
 249   SA ZT0_Shared = SA(SA::encodeZT0State(SA::StateValue::In));
 250   SA ZA_ZT0_Shared = SA(SA::ZA_Shared | SA::encodeZT0State(SA::StateValue::In));
 251
 252   // Shared ZA -> Private ZA Interface
 253   ASSERT_FALSE(ZA_Shared.requiresDisablingZABeforeCall(Private_ZA));
 254   ASSERT_TRUE(ZA_Shared.requiresEnablingZAAfterCall(Private_ZA));
 255
 256   // Shared ZT0 -> Private ZA Interface
 257   ASSERT_TRUE(ZT0_Shared.requiresDisablingZABeforeCall(Private_ZA));
 258   ASSERT_TRUE(ZT0_Shared.requiresPreservingZT0(Private_ZA));
 259   ASSERT_TRUE(ZT0_Shared.requiresEnablingZAAfterCall(Private_ZA));
 260
 261   // Shared ZA & ZT0 -> Private ZA Interface
 262   ASSERT_FALSE(ZA_ZT0_Shared.requiresDisablingZABeforeCall(Private_ZA));
 263   ASSERT_TRUE(ZA_ZT0_Shared.requiresPreservingZT0(Private_ZA));
 264   ASSERT_TRUE(ZA_ZT0_Shared.requiresEnablingZAAfterCall(Private_ZA));
 265
 266   // Shared ZA -> Shared ZA Interface
 267   ASSERT_FALSE(ZA_Shared.requiresDisablingZABeforeCall(ZT0_Shared));
 268   ASSERT_FALSE(ZA_Shared.requiresEnablingZAAfterCall(ZT0_Shared));
 269
 270   // Shared ZT0 -> Shared ZA Interface
 271   ASSERT_FALSE(ZT0_Shared.requiresDisablingZABeforeCall(ZT0_Shared));
 272   ASSERT_FALSE(ZT0_Shared.requiresPreservingZT0(ZT0_Shared));
 273   ASSERT_FALSE(ZT0_Shared.requiresEnablingZAAfterCall(ZT0_Shared));
 274
 275   // Shared ZA & ZT0 -> Shared ZA Interface
 276   ASSERT_FALSE(ZA_ZT0_Shared.requiresDisablingZABeforeCall(ZT0_Shared));
 277   ASSERT_FALSE(ZA_ZT0_Shared.requiresPreservingZT0(ZT0_Shared));
 278   ASSERT_FALSE(ZA_ZT0_Shared.requiresEnablingZAAfterCall(ZT0_Shared));
 279 }