1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
//===---- RemoteTargetMessage.h - LLI out-of-process message protocol -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Definition of the LLIMessageType enum which is used for communication with a
// child process for remote execution.
//
//===----------------------------------------------------------------------===//
#ifndef LLI_REMOTETARGETMESSAGE_H
#define LLI_REMOTETARGETMESSAGE_H
namespace llvm {
// LLI messages from parent-to-child or vice versa follow an exceedingly simple
// protocol where the first four bytes represent the message type, the next
// four bytes represent the size of data for the command and following bytes
// represent the actual data.
//
// The protocol is not intended to be robust, secure or fault-tolerant. It is
// only here for testing purposes and is therefore intended to be the simplest
// implementation that will work. It is assumed that the parent and child
// share characteristics like endianness.
//
// Quick description of the protocol:
//
// { Header + Payload Size + Payload }
//
// The protocol message consist of a header, the payload size (which can be
// zero), and the payload itself. The payload can contain any number of items,
// and the size has to be the sum of them all. Each end is responsible for
// reading/writing the correct number of items with the correct sizes.
//
// The current four known exchanges are:
//
// * Allocate Space:
// Parent: { LLI_AllocateSpace, 8, Alignment, Size }
// Child: { LLI_AllocationResult, 8, Address }
//
// * Load Data:
// Parent: { LLI_LoadDataSection, 8+Size, Address, Data }
// Child: { LLI_LoadComplete, 4, StatusCode }
//
// * Load Code:
// Parent: { LLI_LoadCodeSection, 8+Size, Address, Code }
// Child: { LLI_LoadComplete, 4, StatusCode }
//
// * Execute Code:
// Parent: { LLI_Execute, 8, Address }
// Child: { LLI_ExecutionResult, 4, Result }
//
// It is the responsibility of either side to check for correct headers,
// sizes and payloads, since any inconsistency would misalign the pipe, and
// result in data corruption.
enum LLIMessageType {
LLI_Error = -1,
LLI_ChildActive = 0, // Data = not used
LLI_AllocateSpace, // Data = struct { uint32_t Align, uint_32t Size }
LLI_AllocationResult, // Data = uint64_t Address (child memory space)
LLI_LoadCodeSection, // Data = uint64_t Address, void * SectionData
LLI_LoadDataSection, // Data = uint64_t Address, void * SectionData
LLI_LoadResult, // Data = uint32_t LLIMessageStatus
LLI_Execute, // Data = uint64_t Address
LLI_ExecutionResult, // Data = uint32_t Result
LLI_Terminate // Data = not used
};
enum LLIMessageStatus {
LLI_Status_Success = 0, // Operation succeeded
LLI_Status_NotAllocated, // Address+Size not allocated in child space
LLI_Status_IncompleteMsg // Size received doesn't match request
};
} // end namespace llvm
#endif
|
