-
Notifications
You must be signed in to change notification settings - Fork 394
/
S390Evaluator.hpp
361 lines (311 loc) · 17.3 KB
/
S390Evaluator.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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
/*******************************************************************************
* Copyright (c) 2000, 2019 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 TR_S390_TREE_EVALUATOR_INCL
#define TR_S390_TREE_EVALUATOR_INCL
#include <stddef.h>
#include <stdint.h>
#include "codegen/InstOpCode.hpp"
#include "env/jittypes.h"
#include "il/ILOpCodes.hpp"
#include "codegen/TreeEvaluator.hpp"
namespace TR { class CodeGenerator; }
namespace TR { class Instruction; }
namespace TR { class LabelSymbol; }
namespace TR { class MemoryReference; }
namespace TR { class Node; }
namespace TR { class Register; }
namespace TR { class RegisterDependencyConditions; }
namespace TR { class RegisterPair; }
namespace TR { class TreeEvaluator; }
TR::Register *inlineShortReverseBytes(TR::Node *node, TR::CodeGenerator *cg);
TR::Register *inlineIntegerReverseBytes(TR::Node *node, TR::CodeGenerator *cg);
TR::Register *inlineLongReverseBytes(TR::Node *node, TR::CodeGenerator *cg);
TR::Register *
generateExtendedFloatConstantReg(TR::Node *node, TR::CodeGenerator *cg, int64_t constHi, int64_t constLo,
TR::RegisterDependencyConditions ** depsPtr = NULL);
TR::Instruction* generateS390ImmOp(TR::CodeGenerator *cg,
TR::InstOpCode::Mnemonic memOp,
TR::Node *node,
TR::Register *targetRegister,
float value,
TR::RegisterDependencyConditions *cond = 0,
TR::Instruction * preced = 0);
TR::Instruction* generateS390ImmOp(TR::CodeGenerator *cg,
TR::InstOpCode::Mnemonic memOp,
TR::Node *node,
TR::Register *targetRegister,
double value,
TR::RegisterDependencyConditions *cond = 0,
TR::Instruction * preced = 0);
TR::Instruction* generateS390ImmOp(TR::CodeGenerator *cg,
TR::InstOpCode::Mnemonic memOp,
TR::Node *node,
TR::Register *sourceRegister,
TR::Register *targetRegister,
int64_t value,
TR::RegisterDependencyConditions *cond = 0,
TR::Register * base=0,
TR::Instruction * preced = 0);
TR::Instruction* generateS390ImmOp(TR::CodeGenerator *cg,
TR::InstOpCode::Mnemonic memOp,
TR::Node *node,
TR::Register *srcRegister,
TR::Register *targetRegister,
int32_t value,
TR::RegisterDependencyConditions *cond = 0,
TR::Register * base=0,
TR::Instruction * preced = 0);
TR::Instruction* generateS390ImmToRegister(TR::CodeGenerator * cg,
TR::Node * node,
TR::Register * targetRegister,
intptr_t value,
TR::Instruction * cursor);
/** \brief
* Generates instructions to materialize (load) a 32-bit constant value into a virtual register.
*
* \param cg
* The code generator used to generate the instructions.
*
* \param node
* The node to which the generated instructions will be associated with.
*
* \param value
* The value to load into \p targetRegister.
*
* \param targetRegister
* The virtual register into which to load the \p value.
*
* \param canSetConditionCode
* Determines whether the generated instructions are allowed set any condition code.
*
* \param cursor
* The cursor instruction to append all generated instructions to.
*
* \param dependencies
* The register dependency conditions to which newly allocated registers will be added to if they are needed. All new
* allocated registers will be appended as post conditions to \p cond with an AssignAny condition.
*
* \param literalPoolRegister
* The literal pool register to use if the constant \p value needs to be stored in a literal pool entry.
*
* \return
* The pointer to the last generated instruction to load the supplied \p value.
*/
TR::Instruction* generateLoad32BitConstant(TR::CodeGenerator* cg, TR::Node* node, int32_t value, TR::Register* targetRegister, bool canSetConditionCode, TR::Instruction* cursor = NULL, TR::RegisterDependencyConditions* dependencies = NULL, TR::Register* literalPoolRegister = NULL);
TR::Instruction * genLoadLongConstant(TR::CodeGenerator *cg, TR::Node *node, int64_t value, TR::Register *targetRegister, TR::Instruction *cursor=NULL,TR::RegisterDependencyConditions *cond = 0, TR::Register *base = 0);
TR::Instruction * genLoadAddressConstant(TR::CodeGenerator *cg, TR::Node *node, uintptrj_t value, TR::Register *targetRegister, TR::Instruction *cursor=NULL,TR::RegisterDependencyConditions *cond = 0, TR::Register *base = 0);
TR::Instruction * genLoadAddressConstantInSnippet(TR::CodeGenerator *cg, TR::Node *node, uintptrj_t value, TR::Register *targetRegister, TR::Instruction *cursor=NULL,TR::RegisterDependencyConditions *cond = 0, TR::Register *base = 0, bool isPICCandidate=false);
TR::MemoryReference * sstoreHelper(TR::Node * node, TR::CodeGenerator * cg, bool isReversed=false);
TR::MemoryReference * istoreHelper(TR::Node * node, TR::CodeGenerator * cg, bool isReversed=false);
TR::MemoryReference * lstoreHelper64(TR::Node * node, TR::CodeGenerator * cg, bool isReversed=false);
TR::Register * iloadHelper(TR::Node * node, TR::CodeGenerator * cg, TR::MemoryReference * tempMR, bool isReversed=false);
TR::Register * lloadHelper64(TR::Node * node, TR::CodeGenerator * cg, TR::MemoryReference * tempMR, bool isReversed=false);
TR::Register * sloadHelper(TR::Node * node, TR::CodeGenerator * cg, TR::MemoryReference * tempMR, bool isReversed=false);
TR::Register *getLitPoolBaseReg(TR::Node *node, TR::CodeGenerator * cg);
enum LoadForm
{
RegReg,
MemReg
// Could also add other forms like the Load-and-Add, Load and test, load high, load immediate, etc.
};
template <uint32_t numberOfBits>
TR::Register * genericLoad(TR::Node * node, TR::CodeGenerator * cg, TR::MemoryReference * tempMR, TR::Register * srcRegister);
template <uint32_t numberOfBits, uint32_t numberOfExtendBits, enum LoadForm form>
#if defined(__IBMCPP__) || defined(__ibmxl__)
inline
#endif
TR::Register * genericLoadHelper(TR::Node * node, TR::CodeGenerator * cg, TR::MemoryReference * tempMR, TR::Register * srcRegister, bool isSourceSigned, bool couldIgnoreExtend);
#ifndef _MSC_VER
//Use of above templates is static to the TreeEvaluator.cpp object. Here are the template instantiations available to other objects:
extern template TR::Register * genericLoadHelper<32, 32, MemReg>
(TR::Node * node, TR::CodeGenerator * cg, TR::MemoryReference * tempMR, TR::Register * srcRegister, bool isSourceSigned, bool couldIgnoreExtend);
extern template TR::Register * genericLoadHelper<64, 64, MemReg>
(TR::Node * node, TR::CodeGenerator * cg, TR::MemoryReference * tempMR, TR::Register * srcRegister, bool isSourceSigned, bool couldIgnoreExtend);
#endif
TR::Instruction * generateLoadLiteralPoolAddress(TR::CodeGenerator * cg, TR::Node * node, TR::Register * treg);
TR::Register * generateS390CompareBool(TR::Node * node, TR::CodeGenerator * cg, TR::InstOpCode::Mnemonic branchOp, TR::InstOpCode::S390BranchCondition fBranchOpCond,
TR::InstOpCode::S390BranchCondition rBranchOpCond, bool isUnorderedOK = false);
TR::Register * generateS390CompareBranch(TR::Node * node, TR::CodeGenerator * cg, TR::InstOpCode::Mnemonic branchOp, TR::InstOpCode::S390BranchCondition fBranchOpCond,
TR::InstOpCode::S390BranchCondition rBranchOpCond, bool isUnorderedOK = false);
int32_t getVectorElementSize(TR::Node *node);
int32_t getVectorElementSizeMask(TR::Node *node);
int32_t getVectorElementSizeMask(int8_t size);
#ifndef _MSC_VER
// Because these templates are not defined in headers, but the cpp TreeEvaluator.cpp, suppress implicit instantiation
// using these extern definitions. Unfortunately, Visual Studio likes doing things differently, so for VS, this chunk
// is copied to OMRTreeEvaluator.cpp
extern template TR::Register * TR::TreeEvaluator::narrowCastEvaluator<true, 8>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::narrowCastEvaluator<false, 8>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::narrowCastEvaluator<true, 16>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::narrowCastEvaluator<false, 16>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::narrowCastEvaluator<true, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::narrowCastEvaluator<false, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<true, 8, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<true, 8, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<false, 8, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<false, 8, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<true, 16, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<true, 16, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<false, 16, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<false, 16, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<true, 32, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<true, 32, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<false, 32, 32>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<false, 32, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<true, 64, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::extendCastEvaluator<false, 64, 64>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator< 8, true >(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator< 8, false>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator<16, true >(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator<16, false>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator<32, true >(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator<32, false>(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator<64, true >(TR::Node * node, TR::CodeGenerator * cg);
extern template TR::Register * TR::TreeEvaluator::addressCastEvaluator<64, false>(TR::Node * node, TR::CodeGenerator * cg);
#endif
TR::Register *getConditionCode(TR::Node *node, TR::CodeGenerator *cg, TR::Register *programRegister = NULL);
TR::RegisterDependencyConditions *getGLRegDepsDependenciesFromIfNode(TR::CodeGenerator *cg, TR::Node* ificmpNode);
class TR_S390ComputeCC : public TR::TreeEvaluator
{
public:
static bool setCarryBorrow(TR::Node *flagNode, bool invertValue, TR::CodeGenerator *cg);
static void computeCC(TR::Node *node, TR::Register *ccReg, TR::CodeGenerator *cg);
static void computeCCLogical(TR::Node *node, TR::Register *ccReg, TR::Register *targetReg, TR::CodeGenerator *cg, bool is64Bit=false);
private:
static void saveHostCC(TR::Node *node, TR::Register *ccReg, TR::CodeGenerator *cg);
};
TR::InstOpCode::S390BranchCondition getStandardIfBranchConditionForArraycmp(TR::Node * ifxcmpXXNode, TR::CodeGenerator *cg);
TR::InstOpCode::S390BranchCondition getStandardIfBranchCondition(TR::ILOpCodes opCode, int64_t compareVal);
TR::InstOpCode::S390BranchCondition getButestBranchCondition(TR::ILOpCodes opCode, int32_t compareVal);
bool canUseNodeForFusedMultiply(TR::Node *node);
bool generateFusedMultiplyAddIfPossible(TR::CodeGenerator *cg, TR::Node *addNode, TR::InstOpCode::Mnemonic op, TR::InstOpCode::Mnemonic negateOp = TR::InstOpCode::BAD);
/**
* arraycmpWithPadHelper handles MemcmpWithPad and TR::arraycmpWithPad
*/
class arraycmpWithPadHelper
{
public:
arraycmpWithPadHelper(TR::Node *n,
TR::CodeGenerator *codegen,
bool utf,
bool isFoldedIf_p,
TR::Node *ificmpNode,
bool needResultReg = true,
TR::InstOpCode::S390BranchCondition *returnCond = NULL);
void setupCLCLandCLCLE();
void setupConstCLCL();
TR::Register *generateConstCLCL();
TR::Register *generateCLCL();
TR::Register *generateCLCLE();
void teardownCLCLandCLCLE();
void generateConstCLCSetup();
void generateVarCLCSetup();
void generateConstCLCMainLoop();
void generateVarCLCMainLoop();
void generateConstCLCRemainder();
void generateVarCLCRemainder();
TR::Register* generateCLCUnequal();
void setupConstCLCPadding();
void setupVarCLCPadding();
void generateConstCLCSpacePaddingLoop();
void generateConstCLCPaddingLoop();
void generateVarCLCPaddingLoop();
void teardownCLC();
void generateCLCLitPoolPadding();
void generateCLCFoldedIfResult();
void chooseCLCBranchConditions();
TR::MemoryReference * convertToShortDispMemRef(TR::Node * node,
TR::MemoryReference * largeDispMemRef,
TR::Register * &largeDispReg,
TR::RegisterDependencyConditions *regDeps,
TR::CodeGenerator * cg);
TR::MemoryReference * preemptivelyAdjustLongDisplacementMemoryReference(TR::MemoryReference * memRef);
TR::Register* generate();
private:
TR::Node *source1Node;
TR::Node *source2Node;
TR::Node *source1LenNode;
TR::Node *source2LenNode;
TR::Node *paddingNode;
TR::Node *node;
TR::Register *source1Reg;
TR::Register *source2Reg;
TR::Register *source1LenReg;
TR::Register *source2LenReg;
TR::Register *paddingReg;
TR::RegisterPair *source1PairReg;
TR::RegisterPair *source2PairReg;
TR::Register *retValReg;
TR::Register *litPoolBaseReg;
TR::Register *paddingSrcReg;
TR::Register *loopCountReg;
TR::Register *countReg;
TR::Register *paddingPosReg;
TR::Register *paddingLenReg;
TR::Register *paddingUnequalRetValReg;
int32_t source1Len;
int32_t source2Len;
int32_t addr1Const;
int32_t addr2Const;
int32_t paddingSrcAddr;
int32_t count;
int32_t paddingLen;
int32_t paddingOffset;
int32_t paddingRetCode;
bool constSpacePadding;
size_t paddingLitPoolOffset;
char CLCLpaddingChar;
int32_t maxLen;
int32_t isEqual;
int32_t cmpVal;
bool isAddr1Const;
bool isAddr2Const;
bool isPaddingSrcAddrConst;
bool isLen1Const;
bool isLen2Const;
bool isUTF16;
bool isConst;
bool forceCLCL;
bool isFoldedIf;
bool isSingleTarget;
bool newLitPoolReg;
bool skipUnequal;
bool genResultReg; ///< It is in effect only if isFoldedIf is false.
bool isStartInternalControlFlowSet;
TR::InstOpCode::S390BranchCondition *returnCond;
TR::CodeGenerator *cg;
TR::Node *ificmpNode_;
TR::RegisterDependencyConditions *regDeps;
TR::RegisterDependencyConditions *branchDeps;
TR::LabelSymbol *unequalLabel;
TR::LabelSymbol *doneLabel;
TR::LabelSymbol *remainEndLabel;
TR::LabelSymbol *cmpTargetLabel;
TR::LabelSymbol *cmpDoneLabel;
TR::InstOpCode::S390BranchCondition brCond;
TR::InstOpCode::S390BranchCondition finalBrCond;
bool recDecSource1Node;
bool recDecSource2Node;
const int CLC_THRESHOLD; ///< = 2048;
const int CLCL_THRESHOLD; ///< = 16777216; 2^24 is technically the maximum length for a CLCL
const int PADDING_THRESHOLD; ///< = 496;
};
#endif