[AIX] Skip unsupported ORC JIT RemoteObjectLayerTest on AIX

[daltenty]

Summary

Currently the XCOFF backend does not support writing 64-bit object
files, which the ORC JIT tests will try to exercise if we are on AIX. This patch
selectively disables the tests on AIX for now.

[daltenty]

Note: Would have preferred to use GTEST_SKIP to skip the tests, but we don't seem to have it on our google test version.

[hubert.reinterpretcast]

llvm/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp

22

Do we want to use the do { } while(false) pattern for statement-like macros?

[hubert.reinterpretcast]

Can we make a test that uses the interface that first triggers the error we're seeing in these tests and actually expects the error? If it is not too difficult, then it would help to ensure that the functional tests being skipped here are restored when the error goes away.

[lhames]

LGTM. RemoteObjectLayer is deprecated and will be removed soon, so anything that makes the builders happy is fine by me.

[hubert.reinterpretcast]

In D78813#2006948, @hubert.reinterpretcast wrote:

Can we make a test that uses the interface that first triggers the error we're seeing in these tests and actually expects the error? If it is not too difficult, then it would help to ensure that the functional tests being skipped here are restored when the error goes away.

Given the context from @lhames, I think this LGTM as-is.

[daltenty]

• Add do {} while(false) pattern to macro

[hubert.reinterpretcast]

Confirming that this LGTM.

llvm/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp

 #include "llvm/ExecutionEngine/Orc/RemoteObjectLayer.h"
 #include "OrcTestCommon.h"
 #include "QueueChannel.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 
+// Writing 64-bit XCOFF isn't supported yet, so we need to disable some tests on
+// AIX till it is.
+#ifdef _AIX
+#define SKIPTEST_IF_UNSUPPORTED()                                              \
+  do {                                                                         \
+    return;                                                                    \
+  } while (false)
+#else
+#define SKIPTEST_IF_UNSUPPORTED()                                              \
+  do {                                                                         \
+  } while (false)
+#endif
+
 namespace {
 
 class MockObjectLayer {
 public:
 
   using ObjHandleT = uint64_t;
 
   using ObjectPtr = std::unique_ptr<MemoryBuffer>;
MockObjectLayer::ObjectPtr createTestObject() {
   IRBuilder<> B(&Main->back());
   B.CreateRet(ConstantInt::getSigned(Type::getInt32Ty(Ctx), 42));
 
   SimpleCompiler IRCompiler(*TM);
   return cantFail(IRCompiler(*MB.getModule()));
 }
 
 TEST(RemoteObjectLayer, AddObject) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError = [](Error Err) {
TEST(RemoteObjectLayer, AddObject) {
 
   cantFail(Client.addObject(std::move(TestObject),
                             std::make_shared<NullLegacyResolver>()));
   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, AddObjectFailure) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError =
EXPECT_EQ(ErrMsg, "AddObjectFailure - Test Message")
     << "Expected error string to be \"AddObjectFailure - Test Message\"";
 
   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 
 TEST(RemoteObjectLayer, RemoveObject) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError = [](Error Err) {
TEST(RemoteObjectLayer, RemoveObject) {
 
   cantFail(Client.removeObject(H));
 
   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, RemoveObjectFailure) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError =
TEST(RemoteObjectLayer, RemoveObjectFailure) {
   EXPECT_EQ(ErrMsg, "Object handle 42 not found")
     << "Expected error string to be \"Object handle 42 not found\"";
 
   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, FindSymbol) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError =
EXPECT_EQ(cantFail(Sym1.getAddress()), 0x12348765ULL)
     EXPECT_FALSE(!!Err) << "Symbol 'baz' should not contain an error";
   }
 
   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, FindSymbolIn) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError =
TEST(RemoteObjectLayer, FindSymbolIn) {
   EXPECT_EQ(ErrMsg, "Could not find symbol 'barbaz'")
     << "Expected symbol-not-found error for Sym2";
 
   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, EmitAndFinalize) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError = [](Error Err) {
TEST(RemoteObjectLayer, EmitAndFinalize) {
   auto Err = Client.emitAndFinalize(H);
   EXPECT_FALSE(!!Err) << "emitAndFinalize should work";
 
   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, EmitAndFinalizeFailure) {
+  SKIPTEST_IF_UNSUPPORTED();
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError =