mirror of
https://github.com/RPCS3/llvm.git
synced 2025-04-03 05:41:42 +00:00
bd1968ac09
asynchronous call/handle. Also updates the ORC remote JIT API to use the new
scheme.
The previous version of the RPC tools only supported void functions, and
required the user to manually call a paired function to return results. This
patch replaces the Procedure typedef (which only supported void functions) with
the Function typedef which supports return values, e.g.:
Function<FooId, int32_t(std::string)> Foo;
The RPC primitives and channel operations are also expanded. RPC channels must
support four new operations: startSendMessage, endSendMessage,
startRecieveMessage and endRecieveMessage, to handle channel locking. In
addition, serialization support for tuples to RPCChannels is added to enable
multiple return values.
The RPC primitives are expanded from callAppend, call, expect and handle, to:
appendCallAsync - Make an asynchronous call to the given function.
callAsync - The same as appendCallAsync, but calls send on the channel when
done.
callSTHandling - Blocking call for single-threaded code. Wraps a call to
callAsync then waits on the result, using a user-supplied
handler to handle any callbacks from the remote.
callST - The same as callSTHandling, except that it doesn't handle
callbacks - it expects the result to be the first return.
expect and handle - as before.
handleResponse - Handle a response from the remote.
waitForResult - Wait for the response with the given sequence number to arrive.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@266581 91177308-0d34-0410-b5e6-96231b3b80d8
60 lines
1.9 KiB
C++
60 lines
1.9 KiB
C++
//===---------------- OrcError.cpp - Error codes for ORC ------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Error codes for ORC.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/OrcError.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::orc;
|
|
|
|
namespace {
|
|
|
|
class OrcErrorCategory : public std::error_category {
|
|
public:
|
|
const char *name() const LLVM_NOEXCEPT override { return "orc"; }
|
|
|
|
std::string message(int condition) const override {
|
|
switch (static_cast<OrcErrorCode>(condition)) {
|
|
case OrcErrorCode::RemoteAllocatorDoesNotExist:
|
|
return "Remote allocator does not exist";
|
|
case OrcErrorCode::RemoteAllocatorIdAlreadyInUse:
|
|
return "Remote allocator Id already in use";
|
|
case OrcErrorCode::RemoteMProtectAddrUnrecognized:
|
|
return "Remote mprotect call references unallocated memory";
|
|
case OrcErrorCode::RemoteIndirectStubsOwnerDoesNotExist:
|
|
return "Remote indirect stubs owner does not exist";
|
|
case OrcErrorCode::RemoteIndirectStubsOwnerIdAlreadyInUse:
|
|
return "Remote indirect stubs owner Id already in use";
|
|
case OrcErrorCode::UnexpectedRPCCall:
|
|
return "Unexpected RPC call";
|
|
case OrcErrorCode::UnexpectedRPCResponse:
|
|
return "Unexpected RPC response";
|
|
}
|
|
llvm_unreachable("Unhandled error code");
|
|
}
|
|
};
|
|
|
|
static ManagedStatic<OrcErrorCategory> OrcErrCat;
|
|
}
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
std::error_code orcError(OrcErrorCode ErrCode) {
|
|
typedef std::underlying_type<OrcErrorCode>::type UT;
|
|
return std::error_code(static_cast<UT>(ErrCode), *OrcErrCat);
|
|
}
|
|
}
|
|
}
|