[AIX][llvm][support] Implement getHostCPUName

[daltenty]

Summary

We implement getHostCPUName() for AIX via systemcfg interfaces since access to the processor version register is a privileged operation. We return a value based on the current processor implementation mode.

This fixes the cpu detection used by clang for -mcpu=native.

[hubert.reinterpretcast]

llvm/lib/Support/Host.cpp

1235

I think the interfaces from sys/systemcfg.h can be used?

[daltenty]

llvm/lib/Support/Host.cpp

1235

Thanks, I'll check those out! I was having some trouble finding a documented system interface to get the same functionality, would definitely be preferable if possible.

[daltenty]

• Use systemcfg interfaces instead. Move the getsysttype call to the test.

[daltenty]

• Remove stray program.h

[stevewan]

llvm/lib/Support/Host.cpp

1232

I suspect we're going to update this once POWER_10 is defined by the system header, do we need a TO-DO before that happens?

1237

Might be a dumb question, but why do we need the enum and can't do

switch (_system_configuration.implementation) {
case POWER_4:
...

[daltenty]

llvm/lib/Support/Host.cpp

1237

The original thinking was to benefit from -Wswitch-enum if someone missed something, but to be honest it just likely we'd miss it there, so I think we can just simply this as suggested.

[daltenty]

• Simplify
• Comment

[hubert.reinterpretcast]

llvm/lib/Support/Host.cpp

1227–1232

I'm not entirely sure that "something is better than nothing" is necessarily true here for these. All three have variant implementations/modes (e.g., ppc970, pwr5x, pwr6e) that we aren't handling here.

[daltenty]

llvm/lib/Support/Host.cpp

1227–1232

For pwr5x and pwr6e (IIUC don't think we can actually encounter ppc970), looking at the interfaces it seems that AIX won't distinguish the implementation mode, so I'm not sure if we can easily refine this in those case. Presumably this will still be better than returning 'generic' in those cases though though.

[daltenty]

llvm/lib/Support/Host.cpp

1227–1232

(Or rather ppc970 would presumable appear as POWER 4)

[hubert.reinterpretcast]

llvm/lib/Support/Host.cpp

1227–1232

What I was able to find internally seems to be that the _system_configuration.version field is PV_4_3 for ppc970, PV_5 exactly for pwr5 (and otherwise indicates pwr5x), and PV_6_Compat exactly for pwr6 (i.e., architected mode; and, if not exactly that value, indicates pwr6e).

Note that this does make sense with the historical background that POWER 6 went out with new instructions that were not going to be enshrined into the ISA going forward.

[daltenty]

• Handle specialized cases for pwr 4/5/6

[daltenty]

• Fix formatting

[hubert.reinterpretcast]

LGTM with minor comments on the test.

llvm/unittests/Support/Host.cpp

436

Minor comment wording/formatting nits.

455

Minor nit: Format as English prose (especially since there's already a period at the end).

458–459

... or rtrim.

459

Use drop_back

[stevewan]

llvm/lib/Support/Host.cpp

1227–1232

PV_6_Compat exactly for pwr6 (i.e., architected mode; and, if not exactly that value, indicates pwr6e).

Noted that the accepted change returns pwr6x instead of pwr6e for versions not matching PV_6_Compat. Do we have a reasoning for that?

[daltenty]

llvm/lib/Support/Host.cpp

1227–1232

Good question. This what it appears to be called for LLVM in PPC.td. Why this is the case, I'm not too sure. It's close to what GCC uses (i.e. 'power6x') but our options appear to be incompatible anyway, since we use shortnames and they use long ones, so there's probably a follow on item here if we wanted all the variants of a name to be accepted.

[hubert.reinterpretcast]

llvm/lib/Support/Host.cpp

1227–1232

pwr6x is a suboption name used by Clang (probably based on GCC's power6x). The latter is documented as mainly being about the mffgpr and mftgpr opcodes. This would therefore map to the pwr6e suboption name used by IBM XL. See https://reviews.llvm.org/D58128 for more information.

[daltenty]

• Address comments

[stevewan]

llvm/lib/Support/Host.cpp

1227–1232

Gotcha. So it's just called differently by different compilers, but in the end they are both associated with the "raw mode" of power6.

llvm/lib/Support/Host.cpp

 #include <intrin.h>
 #endif
 #if defined(__APPLE__) && (!defined(__x86_64__))
 #include <mach/host_info.h>
 #include <mach/mach.h>
 #include <mach/mach_host.h>
 #include <mach/machine.h>
 #endif
+#ifdef _AIX
+#include <sys/systemcfg.h>
+#endif
 
 #define DEBUG_TYPE "host-detection"
 
 //===----------------------------------------------------------------------===//
 //
 //  Implementations of the CPU detection routines
 //
 //===----------------------------------------------------------------------===//
StringRef sys::getHostCPUName() {
   switch (hostInfo.cpu_subtype) {
     case CPU_SUBTYPE_ARM_V7S:
       return "swift";
     default:;
     }
 
   return "generic";
 }
+#elif defined(_AIX)
+StringRef sys::getHostCPUName() {
+  switch (_system_configuration.implementation) {
+  case POWER_4:
+    if (_system_configuration.version == PV_4_3)
+      return "970";
+    return "pwr4";
+  case POWER_5:
+    if (_system_configuration.version == PV_5)
+      return "pwr5";
+    return "pwr5x";
+  case POWER_6:
+    if (_system_configuration.version == PV_6_Compat)
+      return "pwr6";
+    return "pwr6x";
+  case POWER_7:
+    return "pwr7";
+  case POWER_8:
+    return "pwr8";
+  case POWER_9:
+    return "pwr9";
+// TODO: simplify this once the macro is available in all OS levels.
+#ifdef POWER_10
+  case POWER_10:
+#else
+  case 0x40000:
+#endif
+    return "pwr10";
+  default:
+    return "generic";
+  }
+}
 #else
 StringRef sys::getHostCPUName() { return "generic"; }
 #endif
 
 #if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
 // On Linux, the number of physical cores can be computed from /proc/cpuinfo,
 // using the number of unique physical/core id pairs. The following
 // implementation reads the /proc/cpuinfo format on an x86_64 system.

llvm/unittests/Support/Host.cpp

TEST_F(HostTest, AIXVersionDetect) {
   if (ConfiguredTargetTriple.getOSMajorVersion())
     return; // The version was configured explicitly; skip.
 
   unsigned TargetMajor, TargetMinor, TargetMicro;
   TargetTriple.getOSVersion(TargetMajor, TargetMinor, TargetMicro);
   ASSERT_EQ(std::tie(SystemMajor, SystemMinor),
             std::tie(TargetMajor, TargetMinor));
 }
+
+TEST_F(HostTest, AIXHostCPUDetect) {
+  // Return a value based on the current processor implementation mode.
+  const char *ExePath = "/usr/sbin/getsystype";
+  StringRef argv[] = {ExePath, "-i"};
+  std::unique_ptr<char[]> Buffer;
+  off_t Size;
+  ASSERT_EQ(runAndGetCommandOutput(ExePath, argv, Buffer, Size), true);
+  StringRef CPU(Buffer.get(), Size);
+  StringRef MCPU = StringSwitch<const char *>(CPU)
+                       .Case("POWER 4\n", "pwr4")
+                       .Case("POWER 5\n", "pwr5")
+                       .Case("POWER 6\n", "pwr6")
+                       .Case("POWER 7\n", "pwr7")
+                       .Case("POWER 8\n", "pwr8")
+                       .Case("POWER 9\n", "pwr9")
+                       .Case("POWER 10\n", "pwr10")
+                       .Default("unknown");
+
+  StringRef HostCPU = sys::getHostCPUName();
+
+  // Just do the comparison on the base implementation mode.
+  if (HostCPU == "970")
+    HostCPU = StringRef("pwr4");
+  else
+    HostCPU = HostCPU.rtrim('x');
+
+  EXPECT_EQ(HostCPU, MCPU);
+}
 #endif