CoCalc -- J9IL.cpp

GitHub Repository: PojavLauncherTeam/openj9
Path: blob/master/runtime/compiler/il/J9IL.cpp
⁶⁰⁰⁰ views
1
/*******************************************************************************
2
 * Copyright (c) 2000, 2021 IBM Corp. and others
3
 *
4
 * This program and the accompanying materials are made available under
5
 * the terms of the Eclipse Public License 2.0 which accompanies this
6
 * distribution and is available at https://www.eclipse.org/legal/epl-2.0/
7
 * or the Apache License, Version 2.0 which accompanies this distribution and
8
 * is available at https://www.apache.org/licenses/LICENSE-2.0.
9
 *
10
 * This Source Code may also be made available under the following
11
 * Secondary Licenses when the conditions for such availability set
12
 * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU
13
 * General Public License, version 2 with the GNU Classpath
14
 * Exception [1] and GNU General Public License, version 2 with the
15
 * OpenJDK Assembly Exception [2].
16
 *
17
 * [1] https://www.gnu.org/software/classpath/license.html
18
 * [2] http://openjdk.java.net/legal/assembly-exception.html
19
 *
20
 * 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
21
 *******************************************************************************/
22

23
#include "il/IL.hpp"
24
#include "il/ILOpCodes.hpp"
25
#include "il/DataTypes.hpp"
26
#include "infra/Assert.hpp"
27

28

29
TR::ILOpCodes J9::IL::opCodesForConst[] =
30
   {
31
   TR::BadILOp,    // TR::PackedDecimal
32
   TR::BadILOp,    // TR::ZonedDecimal
33
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingEmbedded
34
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingSeparate
35
   TR::BadILOp,    // TR::ZonedDecimalSignTrailingSeparate
36
   TR::BadILOp,    // TR::UnicodeDecimal
37
   TR::BadILOp,    // TR::UnicodeDecimalSignLeading
38
   TR::BadILOp     // TR::UnicodeDecimalSignTrailing
39
   };
40

41
TR::ILOpCodes J9::IL::opCodesForDirectLoad[] =
42
   {
43
   TR::pdload,     // TR::PackedDecimal
44
   TR::zdload,     // TR::ZonedDecimal
45
   TR::zdsleLoad,  // TR::ZonedDecimalSignLeadingEmbedded
46
   TR::zdslsLoad,  // TR::ZonedDecimalSignLeadingSeparate
47
   TR::zdstsLoad,  // TR::ZonedDecimalSignTrailingSeparate
48
   TR::udLoad,     // TR::UnicodeDecimal
49
   TR::udslLoad,   // TR::UnicodeDecimalSignLeading
50
   TR::udstLoad    // TR::UnicodeDecimalSignTrailing
51
   };
52

53
TR::ILOpCodes J9::IL::opCodesForDirectStore[] =
54
   {
55
   TR::pdstore,    // TR::PackedDecimal
56
   TR::zdstore,    // TR::ZonedDecimal
57
   TR::zdsleStore, // TR::ZonedDecimalSignLeadingEmbedded
58
   TR::zdslsStore, // TR::ZonedDecimalSignLeadingSeparate
59
   TR::zdstsStore, // TR::ZonedDecimalSignTrailingSeparate
60
   TR::udStore,    // TR::UnicodeDecimal
61
   TR::udslStore,  // TR::UnicodeDecimalSignLeading
62
   TR::udstStore   // TR::UnicodeDecimalSignTrailing
63
   };
64

65
TR::ILOpCodes J9::IL::opCodesForIndirectLoad[] =
66
   {
67
   TR::pdloadi,    // TR::PackedDecimal
68
   TR::zdloadi,    // TR::ZonedDecimal
69
   TR::zdsleLoadi, // TR::ZonedDecimalSignLeadingEmbedded
70
   TR::zdslsLoadi, // TR::ZonedDecimalSignLeadingSeparate
71
   TR::zdstsLoadi, // TR::ZonedDecimalSignTrailingSeparate
72
   TR::udLoadi,    // TR::UnicodeDecimal
73
   TR::udslLoadi,  // TR::UnicodeDecimalSignLeading
74
   TR::udstLoadi   // TR::UnicodeDecimalSignTrailing
75
   };
76

77
TR::ILOpCodes J9::IL::opCodesForIndirectStore[] =
78
   {
79
   TR::pdstorei,    // TR::PackedDecimal
80
   TR::zdstorei,    // TR::ZonedDecimal
81
   TR::zdsleStorei, // TR::ZonedDecimalSignLeadingEmbedded
82
   TR::zdslsStorei, // TR::ZonedDecimalSignLeadingSeparate
83
   TR::zdstsStorei, // TR::ZonedDecimalSignTrailingSeparate
84
   TR::udStorei,    // TR::UnicodeDecimal
85
   TR::udslStorei,  // TR::UnicodeDecimalSignLeading
86
   TR::udstStorei   // TR::UnicodeDecimalSignTrailing
87
   };
88

89
TR::ILOpCodes J9::IL::opCodesForIndirectArrayLoad[] =
90
   {
91
   TR::pdloadi,    // TR::PackedDecimal
92
   TR::zdloadi,    // TR::ZonedDecimal
93
   TR::zdsleLoadi, // TR::ZonedDecimalSignLeadingEmbedded
94
   TR::zdslsLoadi, // TR::ZonedDecimalSignLeadingSeparate
95
   TR::zdstsLoadi, // TR::ZonedDecimalSignTrailingSeparate
96
   TR::udLoadi,    // TR::UnicodeDecimal
97
   TR::udslLoadi,  // TR::UnicodeDecimalSignLeading
98
   TR::udstLoadi   // TR::UnicodeDecimalSignTrailing
99
   };
100

101
TR::ILOpCodes J9::IL::opCodesForIndirectArrayStore[] =
102
   {
103
   TR::pdstorei,    // TR::PackedDecimal
104
   TR::zdstorei,    // TR::ZonedDecimal
105
   TR::zdsleStorei, // TR::ZonedDecimalSignLeadingEmbedded
106
   TR::zdslsStorei, // TR::ZonedDecimalSignLeadingSeparate
107
   TR::zdstsStorei, // TR::ZonedDecimalSignTrailingSeparate
108
   TR::udStorei,    // TR::UnicodeDecimal
109
   TR::udslStorei,  // TR::UnicodeDecimalSignLeading
110
   TR::udstStorei   // TR::UnicodeDecimalSignTrailing
111
   };
112

113
TR::ILOpCodes J9::IL::opCodesForRegisterLoad[] =
114
   {
115
   TR::BadILOp,    // TR::PackedDecimal
116
   TR::BadILOp,    // TR::ZonedDecimal
117
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingEmbedded
118
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingSeparate
119
   TR::BadILOp,    // TR::ZonedDecimalSignTrailingSeparate
120
   TR::BadILOp,    // TR::UnicodeDecimal
121
   TR::BadILOp,    // TR::UnicodeDecimalSignLeading
122
   TR::BadILOp     // TR::UnicodeDecimalSignTrailing
123
   };
124

125
TR::ILOpCodes J9::IL::opCodesForRegisterStore[] =
126
   {
127
   TR::BadILOp,    // TR::PackedDecimal
128
   TR::BadILOp,    // TR::ZonedDecimal
129
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingEmbedded
130
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingSeparate
131
   TR::BadILOp,    // TR::ZonedDecimalSignTrailingSeparate
132
   TR::BadILOp,    // TR::UnicodeDecimal
133
   TR::BadILOp,    // TR::UnicodeDecimalSignLeading
134
   TR::BadILOp     // TR::UnicodeDecimalSignTrailing
135
   };
136

137
TR::ILOpCodes J9::IL::opCodesForCompareEquals[] =
138
   {
139
   TR::pdcmpeq,    // TR::PackedDecimal
140
   TR::BadILOp,    // TR::ZonedDecimal
141
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingEmbedded
142
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingSeparate
143
   TR::BadILOp,    // TR::ZonedDecimalSignTrailingSeparate
144
   TR::BadILOp,    // TR::UnicodeDecimal
145
   TR::BadILOp,    // TR::UnicodeDecimalSignLeading
146
   TR::BadILOp     // TR::UnicodeDecimalSignTrailing
147
   };
148

149
TR::ILOpCodes J9::IL::opCodesForCompareNotEquals[] =
150
   {
151
   TR::pdcmpne,    // TR::PackedDecimal
152
   TR::BadILOp,    // TR::ZonedDecimal
153
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingEmbedded
154
   TR::BadILOp,    // TR::ZonedDecimalSignLeadingSeparate
155
   TR::BadILOp,    // TR::ZonedDecimalSignTrailingSeparate
156
   TR::BadILOp,    // TR::UnicodeDecimal
157
   TR::BadILOp,    // TR::UnicodeDecimalSignLeading
158
   TR::BadILOp     // TR::UnicodeDecimalSignTrailing
159
   };
160

161
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForConst) / sizeof(J9::IL::opCodesForConst[0])),
162
              "J9::IL::opCodesForConst is not the correct size");
163

164
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForDirectLoad) / sizeof(J9::IL::opCodesForDirectLoad[0])),
165
              "J9::IL::opCodesForDirectLoad is not the correct size");
166

167
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForDirectStore) / sizeof(J9::IL::opCodesForDirectStore[0])),
168
              "J9::IL::opCodesForDirectStore is not the correct size");
169

170
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForIndirectLoad) / sizeof(J9::IL::opCodesForIndirectLoad[0])),
171
              "J9::IL::opCodesForIndirectLoad is not the correct size");
172

173
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForIndirectStore) / sizeof(J9::IL::opCodesForIndirectStore[0])),
174
              "J9::IL::opCodesForIndirectStore is not the correct size");
175

176
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForIndirectArrayLoad) / sizeof(J9::IL::opCodesForIndirectArrayLoad[0])),
177
              "J9::IL::opCodesForIndirectArrayLoad is not the correct size");
178

179
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForIndirectArrayStore) / sizeof(J9::IL::opCodesForIndirectArrayStore[0])),
180
              "J9::IL::opCodesForIndirectArrayStore is not the correct size");
181

182
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForRegisterLoad) / sizeof(J9::IL::opCodesForRegisterLoad[0])),
183
              "J9::IL::opCodesForRegisterLoad is not the correct size");
184

185
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForRegisterStore) / sizeof(J9::IL::opCodesForRegisterStore[0])),
186
              "J9::IL::opCodesForRegisterStore is not the correct size");
187

188
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForCompareEquals) / sizeof(J9::IL::opCodesForCompareEquals[0])),
189
              "J9::IL::opCodesForCompareEquals is not the correct size");
190

191
static_assert(TR::LastJ9Type - TR::FirstJ9Type + 1 == (sizeof(J9::IL::opCodesForCompareNotEquals) / sizeof(J9::IL::opCodesForCompareNotEquals[0])),
192
              "J9::IL::opCodesForCompareNotEquals is not the correct size");
193

194

195
TR::ILOpCodes
196
J9::IL::opCodeForCorrespondingIndirectLoad(TR::ILOpCodes loadOpCode)
197
   {
198

199
   if (loadOpCode <= TR::LastOMROp)
200
      {
201
      return OMR::IL::opCodeForCorrespondingIndirectLoad(loadOpCode);
202
      }
203

204
   switch (loadOpCode)
205
      {
206
      case TR::pdloadi: return TR::pdstorei;
207
      case TR::zdloadi: return TR::zdstorei;
208
      case TR::zdsleLoadi: return TR::zdsleStorei;
209
      case TR::zdslsLoadi: return TR::zdslsStorei;
210
      case TR::zdstsLoadi: return TR::zdstsStorei;
211
      case TR::udLoadi: return TR::udStorei;
212
      case TR::udslLoadi: return TR::udslStorei;
213
      case TR::udstLoadi: return TR::udstStorei;
214
      default: return OMR::IL::opCodeForCorrespondingIndirectLoad(loadOpCode);
215
      }
216

217
   TR_ASSERT(0, "no corresponding store opcode for specified load opcode");
218
   return TR::BadILOp;
219
   }
220

221

222
TR::ILOpCodes
223
J9::IL::opCodeForCorrespondingIndirectStore(TR::ILOpCodes storeOpCode)
224
   {
225

226
   if (storeOpCode <= TR::LastOMROp)
227
      {
228
      return OMR::IL::opCodeForCorrespondingIndirectStore(storeOpCode);
229
      }
230

231
   switch (storeOpCode)
232
      {
233
      case TR::pdstorei: return TR::pdloadi;
234
      case TR::zdstorei: return TR::zdloadi;
235
      case TR::zdsleStorei: return TR::zdsleLoadi;
236
      case TR::zdslsStorei: return TR::zdslsLoadi;
237
      case TR::zdstsStorei: return TR::zdstsLoadi;
238
      case TR::udStorei: return TR::udLoadi;
239
      case TR::udslStorei: return TR::udslLoadi;
240
      case TR::udstStorei: return TR::udstLoadi;
241
      default: return OMR::IL::opCodeForCorrespondingIndirectStore(storeOpCode);
242
      }
243

244
   TR_ASSERT(0, "no corresponding load opcode for specified store opcode");
245
   return TR::BadILOp;
246
   }
247

248
TR::ILOpCodes
249
J9::IL::opCodeForCorrespondingDirectLoad(TR::ILOpCodes loadOpCode)
250
   {
251

252
   if (loadOpCode <= TR::LastOMROp)
253
      {
254
      return OMR::IL::opCodeForCorrespondingDirectLoad(loadOpCode);
255
      }
256

257
   switch (loadOpCode)
258
      {
259
      case TR::pdload: return TR::pdstore;
260
      case TR::zdload: return TR::zdstore;
261
      case TR::zdsleLoad: return TR::zdsleStore;
262
      case TR::zdslsLoad: return TR::zdslsStore;
263
      case TR::zdstsLoad: return TR::zdstsStore;
264
      case TR::udLoad: return TR::udStore;
265
      case TR::udslLoad: return TR::udslStore;
266
      case TR::udstLoad: return TR::udstStore;
267
      default: return OMR::IL::opCodeForCorrespondingDirectLoad(loadOpCode);
268
      }
269

270
   TR_ASSERT(0, "no corresponding store opcode for specified load opcode");
271
   return TR::BadILOp;
272
   }
273

274

275
TR::ILOpCodes
276
J9::IL::opCodeForCorrespondingDirectStore(TR::ILOpCodes storeOpCode)
277
   {
278

279
   if (storeOpCode <= TR::LastOMROp)
280
      {
281
      return OMR::IL::opCodeForCorrespondingDirectStore(storeOpCode);
282
      }
283

284
   switch (storeOpCode)
285
      {
286
      case TR::pdstore: return TR::pdload;
287
      case TR::zdstore: return TR::zdload;
288
      case TR::zdsleStore: return TR::zdsleLoad;
289
      case TR::zdslsStore: return TR::zdslsLoad;
290
      case TR::zdstsStore: return TR::zdstsLoad;
291
      case TR::udStore: return TR::udLoad;
292
      case TR::udslStore: return TR::udslLoad;
293
      case TR::udstStore: return TR::udstLoad;
294
      default: return OMR::IL::opCodeForCorrespondingDirectStore(storeOpCode);
295
      }
296

297
   TR_ASSERT(0, "no corresponding load opcode for specified store opcode");
298
   return TR::BadILOp;
299
   }
300

301
TR::ILOpCodes
302
J9::IL::opCodeForConst(TR::DataType dt)
303
   {
304
   if (dt == TR::Int8 || dt == TR::Int16)
305
      {
306
      return TR::iconst;
307
      }
308

309
   if (dt < TR::FirstJ9Type)
310
      {
311
      return OMR::IL::opCodeForConst(dt);
312
      }
313

314
   return J9::IL::opCodesForConst[dt - TR::FirstJ9Type];
315
   }
316

317

318
TR::ILOpCodes
319
J9::IL::opCodeForDirectReadBarrier(TR::DataType dt)
320
   {
321
   if (dt == TR::Int8 || dt == TR::Int16)
322
      {
323
      return TR::irdbar;
324
      }
325

326
   return OMR::IL::opCodeForDirectReadBarrier(dt);
327
   }
328

329
TR::ILOpCodes
330
J9::IL::opCodeForDirectLoad(TR::DataType dt)
331
   {
332
   if (dt == TR::Int8 || dt == TR::Int16)
333
      {
334
      return TR::iload;
335
      }
336

337
   if (dt < TR::FirstJ9Type)
338
      {
339
      return OMR::IL::opCodeForDirectLoad(dt);
340
      }
341

342
   return J9::IL::opCodesForDirectLoad[dt - TR::FirstJ9Type];
343
   }
344

345
TR::ILOpCodes
346
J9::IL::opCodeForDirectStore(TR::DataType dt)
347
   {
348
   if (dt == TR::Int8 || dt == TR::Int16)
349
      {
350
      return TR::istore;
351
      }
352

353
   if (dt < TR::FirstJ9Type)
354
      {
355
      return OMR::IL::opCodeForDirectStore(dt);
356
      }
357

358
   return J9::IL::opCodesForDirectStore[dt - TR::FirstJ9Type];
359
   }
360

361
TR::ILOpCodes
362
J9::IL::opCodeForDirectWriteBarrier(TR::DataType dt)
363
   {
364
   if (dt == TR::Int8 || dt == TR::Int16)
365
      {
366
      return TR::iwrtbar;
367
      }
368

369
   return OMR::IL::opCodeForDirectWriteBarrier(dt);
370
   }
371

372
TR::ILOpCodes
373
J9::IL::opCodeForIndirectReadBarrier(TR::DataType dt)
374
   {
375
   if (dt == TR::Int8 || dt == TR::Int16)
376
      {
377
      return TR::irdbari;
378
      }
379

380
   return OMR::IL::opCodeForIndirectReadBarrier(dt);
381
   }
382

383
TR::ILOpCodes
384
J9::IL::opCodeForIndirectLoad(TR::DataType dt)
385
   {
386
   if (dt == TR::Int8 || dt == TR::Int16)
387
      {
388
      return TR::iloadi;
389
      }
390

391
   if (dt < TR::FirstJ9Type)
392
      {
393
      return OMR::IL::opCodeForIndirectLoad(dt);
394
      }
395

396
   return J9::IL::opCodesForIndirectLoad[dt - TR::FirstJ9Type];
397
   }
398

399
TR::ILOpCodes
400
J9::IL::opCodeForIndirectStore(TR::DataType dt)
401
   {
402
   if (dt == TR::Int8 || dt == TR::Int16)
403
      {
404
      return TR::istorei;
405
      }
406

407
   if (dt < TR::FirstJ9Type)
408
      {
409
      return OMR::IL::opCodeForIndirectStore(dt);
410
      }
411

412
   return J9::IL::opCodesForIndirectStore[dt - TR::FirstJ9Type];
413
   }
414

415
TR::ILOpCodes
416
J9::IL::opCodeForIndirectWriteBarrier(TR::DataType dt)
417
   {
418
   if (dt == TR::Int8 || dt == TR::Int16)
419
      {
420
      return TR::iwrtbari;
421
      }
422

423
   return OMR::IL::opCodeForIndirectWriteBarrier(dt);
424
   }
425

426

427
TR::ILOpCodes
428
J9::IL::opCodeForIndirectArrayLoad(TR::DataType dt)
429
   {
430
   if (dt < TR::FirstJ9Type)
431
      {
432
      return OMR::IL::opCodeForIndirectArrayLoad(dt);
433
      }
434

435
   return J9::IL::opCodesForIndirectArrayLoad[dt - TR::FirstJ9Type];
436
   }
437

438
TR::ILOpCodes
439
J9::IL::opCodeForIndirectArrayStore(TR::DataType dt)
440
   {
441
   if (dt < TR::FirstJ9Type)
442
      {
443
      return OMR::IL::opCodeForIndirectArrayStore(dt);
444
      }
445

446
   return J9::IL::opCodesForIndirectArrayStore[dt - TR::FirstJ9Type];
447
   }
448

449
TR::ILOpCodes
450
J9::IL::opCodeForRegisterLoad(TR::DataType dt)
451
   {
452
   if (dt < TR::FirstJ9Type)
453
      {
454
      return OMR::IL::opCodeForRegisterLoad(dt);
455
      }
456

457
   return J9::IL::opCodesForRegisterLoad[dt - TR::FirstJ9Type];
458
   }
459

460
TR::ILOpCodes
461
J9::IL::opCodeForRegisterStore(TR::DataType dt)
462
   {
463
   if (dt < TR::FirstJ9Type)
464
      {
465
      return OMR::IL::opCodeForRegisterStore(dt);
466
      }
467

468
   return J9::IL::opCodesForRegisterStore[dt - TR::FirstJ9Type];
469
   }
470

471
TR::ILOpCodes
472
J9::IL::opCodeForCompareEquals(TR::DataType dt)
473
   {
474
   if (dt == TR::Int8 || dt == TR::Int16)
475
      {
476
      return TR::icmpeq;
477
      }
478

479
   if (dt < TR::FirstJ9Type)
480
      {
481
      return OMR::IL::opCodeForCompareEquals(dt);
482
      }
483

484
   return J9::IL::opCodesForCompareEquals[dt - TR::FirstJ9Type];
485
   }
486

487
TR::ILOpCodes
488
J9::IL::opCodeForCompareNotEquals(TR::DataType dt)
489
   {
490
   if (dt == TR::Int8 || dt == TR::Int16)
491
      {
492
      return TR::icmpne;
493
      }
494

495
   if (dt < TR::FirstJ9Type)
496
      {
497
      return OMR::IL::opCodeForCompareNotEquals(dt);
498
      }
499

500
   return J9::IL::opCodesForCompareNotEquals[dt - TR::FirstJ9Type];
501
   }
502

503

504
Product

Resources

Company
