-
Notifications
You must be signed in to change notification settings - Fork 392
/
RVSystemLinkage.hpp
169 lines (145 loc) · 5.24 KB
/
RVSystemLinkage.hpp
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
/*******************************************************************************
* Copyright (c) 2019, 2021 IBM Corp. and others
*
* This program and the accompanying materials are made available under
* the terms of the Eclipse Public License 2.0 which accompanies this
* distribution and is available at http://eclipse.org/legal/epl-2.0
* or the Apache License, Version 2.0 which accompanies this distribution
* and is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License, v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
*******************************************************************************/
#ifndef OMR_RV_SYSTEMLINKAGE_INCL
#define OMR_RV_SYSTEMLINKAGE_INCL
#include "codegen/Linkage.hpp"
#include <stdint.h>
#include "codegen/Register.hpp"
namespace TR { class AutomaticSymbol; }
namespace TR { class CodeGenerator; }
namespace TR { class Instruction; }
namespace TR { class Node; }
namespace TR { class ParameterSymbol; }
namespace TR { class RegisterDependencyConditions; }
namespace TR { class ResolvedMethodSymbol; }
template <class T> class List;
namespace TR {
struct RVSystemLinkageProperties : public RVLinkageProperties {
RVSystemLinkageProperties();
};
class RVSystemLinkage : public TR::Linkage
{
protected:
static const TR::RVSystemLinkageProperties _properties;
public:
/**
* @brief Constructor
* @param[in] cg : CodeGenerator
*/
RVSystemLinkage(TR::CodeGenerator *cg);
/**
* @brief Gets linkage properties
* @return Linkage properties
*/
virtual const TR::RVLinkageProperties& getProperties();
/**
* @brief Gets the RightToLeft flag
* @return RightToLeft flag
*/
virtual uint32_t getRightToLeft();
/**
* @brief Maps symbols to locations on stack
* @param[in] method : method for which symbols are mapped on stack
*/
virtual void mapStack(TR::ResolvedMethodSymbol *method);
/**
* @brief Maps an automatic symbol to an index on stack
* @param[in] p : automatic symbol
* @param[in/out] stackIndex : index on stack
*/
virtual void mapSingleAutomatic(TR::AutomaticSymbol *p, uint32_t &stackIndex);
/**
* @brief Initializes RV RealRegister linkage
*/
virtual void initRVRealRegisterLinkage();
/**
* @brief Creates method prologue
* @param[in] cursor : instruction cursor
*/
virtual void createPrologue(TR::Instruction *cursor);
/**
* @brief Creates method prologue
* @param[in] cursor : instruction cursor
*/
virtual void createPrologue(TR::Instruction *cursor, List<TR::ParameterSymbol> &parm);
/**
* @brief Creates method epilogue
* @param[in] cursor : instruction cursor
*/
virtual void createEpilogue(TR::Instruction *cursor);
/**
* @brief Builds method arguments
* @param[in] node : caller node
* @param[in] dependencies : register dependency conditions
*/
virtual int32_t buildArgs(
TR::Node *callNode,
TR::RegisterDependencyConditions *dependencies);
/**
* @brief Builds dispatch to method (either direct or indirect)
* @param[in] node : caller node
*/
virtual TR::Register *buildDispatch(TR::Node *callNode);
/**
* @brief Builds direct dispatch to method
* @param[in] node : caller node
*/
virtual TR::Register *buildDirectDispatch(TR::Node *callNode)
{
return buildDispatch(callNode);
}
/**
* @brief Builds indirect dispatch to method
* @param[in] node : caller node
*/
virtual TR::Register *buildIndirectDispatch(TR::Node *callNode)
{
return buildDispatch(callNode);
}
/**
* @brief Provides the entry point in a method to use when that method is invoked
* from a method compiled with the same linkage.
*
* @details
* When asked on the method currently being compiled, this API will return 0 if
* asked before code memory has been allocated.
*
* The compiled method entry point may be the same as the interpreter entry point.
*
* @return The entry point for compiled methods to use; 0 if the entry point is unknown
*/
virtual intptr_t entryPointFromCompiledMethod();
/**
* @brief Provides the entry point in a method to use when that method is invoked
* from an interpreter using the same linkage.
*
* @details
* When asked on the method currently being compiled, this API will return 0 if
* asked before code memory has been allocated.
*
* The compiled method entry point may be the same as the interpreter entry point.
*
* @return The entry point for interpreted methods to use; 0 if the entry point is unknown
*/
virtual intptr_t entryPointFromInterpretedMethod();
};
}
#endif