211 private:
212 CodeEmitInfo* _info;
213 int _offset;
214
215 public:
216 ImplicitNullCheckStub(int offset, CodeEmitInfo* info)
217 : _info(info), _offset(offset) {
218 }
219 virtual void emit_code(LIR_Assembler* e);
220 virtual CodeEmitInfo* info() const { return _info; }
221 virtual bool is_exception_throw_stub() const { return true; }
222 virtual void visit(LIR_OpVisitState* visitor) {
223 visitor->do_slow_case(_info);
224 }
225 #ifndef PRODUCT
226 virtual void print_name(outputStream* out) const { out->print("ImplicitNullCheckStub"); }
227 #endif // PRODUCT
228 };
229
230
231 class NewInstanceStub: public CodeStub {
232 private:
233 ciInstanceKlass* _klass;
234 LIR_Opr _klass_reg;
235 LIR_Opr _result;
236 CodeEmitInfo* _info;
237 StubId _stub_id;
238
239 public:
240 NewInstanceStub(LIR_Opr klass_reg, LIR_Opr result, ciInstanceKlass* klass, CodeEmitInfo* info, StubId stub_id);
241 virtual void emit_code(LIR_Assembler* e);
242 virtual CodeEmitInfo* info() const { return _info; }
243 virtual void visit(LIR_OpVisitState* visitor) {
244 visitor->do_slow_case(_info);
245 visitor->do_input(_klass_reg);
246 visitor->do_output(_result);
247 }
248 #ifndef PRODUCT
249 virtual void print_name(outputStream* out) const { out->print("NewInstanceStub"); }
250 #endif // PRODUCT
263 virtual void emit_code(LIR_Assembler* e);
264 virtual CodeEmitInfo* info() const { return _info; }
265 virtual void visit(LIR_OpVisitState* visitor) {
266 visitor->do_slow_case(_info);
267 visitor->do_input(_klass_reg);
268 visitor->do_input(_length);
269 assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
270 }
271 #ifndef PRODUCT
272 virtual void print_name(outputStream* out) const { out->print("NewTypeArrayStub"); }
273 #endif // PRODUCT
274 };
275
276
277 class NewObjectArrayStub: public CodeStub {
278 private:
279 LIR_Opr _klass_reg;
280 LIR_Opr _length;
281 LIR_Opr _result;
282 CodeEmitInfo* _info;
283
284 public:
285 NewObjectArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info);
286 virtual void emit_code(LIR_Assembler* e);
287 virtual CodeEmitInfo* info() const { return _info; }
288 virtual void visit(LIR_OpVisitState* visitor) {
289 visitor->do_slow_case(_info);
290 visitor->do_input(_klass_reg);
291 visitor->do_input(_length);
292 assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
293 }
294 #ifndef PRODUCT
295 virtual void print_name(outputStream* out) const { out->print("NewObjectArrayStub"); }
296 #endif // PRODUCT
297 };
298
299
300 class MonitorAccessStub: public CodeStub {
301 protected:
302 LIR_Opr _obj_reg;
303 LIR_Opr _lock_reg;
304
305 public:
306 MonitorAccessStub(LIR_Opr obj_reg, LIR_Opr lock_reg) {
307 _obj_reg = obj_reg;
308 _lock_reg = lock_reg;
309 }
310
311 #ifndef PRODUCT
312 virtual void print_name(outputStream* out) const { out->print("MonitorAccessStub"); }
313 #endif // PRODUCT
314 };
315
316
317 class MonitorEnterStub: public MonitorAccessStub {
318 private:
319 CodeEmitInfo* _info;
320
321 public:
322 MonitorEnterStub(LIR_Opr obj_reg, LIR_Opr lock_reg, CodeEmitInfo* info)
323 : MonitorAccessStub(obj_reg, lock_reg) {
324 _info = new CodeEmitInfo(info);
325 FrameMap* f = Compilation::current()->frame_map();
326 f->update_reserved_argument_area_size(2 * BytesPerWord);
327 }
328
329 virtual void emit_code(LIR_Assembler* e);
330 virtual CodeEmitInfo* info() const { return _info; }
331 virtual void visit(LIR_OpVisitState* visitor) {
332 visitor->do_input(_obj_reg);
333 visitor->do_input(_lock_reg);
334 visitor->do_slow_case(_info);
335 }
336 #ifndef PRODUCT
337 virtual void print_name(outputStream* out) const { out->print("MonitorEnterStub"); }
338 #endif // PRODUCT
339 };
340
341
342 class MonitorExitStub: public MonitorAccessStub {
343 private:
344 int _monitor_ix;
345
346 public:
347 MonitorExitStub(LIR_Opr lock_reg, int monitor_ix)
348 : MonitorAccessStub(LIR_OprFact::illegalOpr, lock_reg),
349 _monitor_ix(monitor_ix) { }
350 virtual void emit_code(LIR_Assembler* e);
351 virtual void visit(LIR_OpVisitState* visitor) {
352 assert(_obj_reg->is_illegal(), "unused");
353 visitor->do_temp(_lock_reg);
|
211 private:
212 CodeEmitInfo* _info;
213 int _offset;
214
215 public:
216 ImplicitNullCheckStub(int offset, CodeEmitInfo* info)
217 : _info(info), _offset(offset) {
218 }
219 virtual void emit_code(LIR_Assembler* e);
220 virtual CodeEmitInfo* info() const { return _info; }
221 virtual bool is_exception_throw_stub() const { return true; }
222 virtual void visit(LIR_OpVisitState* visitor) {
223 visitor->do_slow_case(_info);
224 }
225 #ifndef PRODUCT
226 virtual void print_name(outputStream* out) const { out->print("ImplicitNullCheckStub"); }
227 #endif // PRODUCT
228 };
229
230
231 class LoadFlattenedArrayStub: public CodeStub {
232 private:
233 LIR_Opr _array;
234 LIR_Opr _index;
235 LIR_Opr _result;
236 LIR_Opr _scratch_reg;
237 CodeEmitInfo* _info;
238
239 public:
240 LoadFlattenedArrayStub(LIR_Opr array, LIR_Opr index, LIR_Opr result, CodeEmitInfo* info);
241 virtual void emit_code(LIR_Assembler* e);
242 virtual CodeEmitInfo* info() const { return _info; }
243 virtual void visit(LIR_OpVisitState* visitor) {
244 visitor->do_slow_case(_info);
245 visitor->do_input(_array);
246 visitor->do_input(_index);
247 visitor->do_output(_result);
248 if (_scratch_reg != LIR_OprFact::illegalOpr) {
249 visitor->do_temp(_scratch_reg);
250 }
251 }
252
253 #ifndef PRODUCT
254 virtual void print_name(outputStream* out) const { out->print("LoadFlattenedArrayStub"); }
255 #endif // PRODUCT
256 };
257
258
259 class StoreFlattenedArrayStub: public CodeStub {
260 private:
261 LIR_Opr _array;
262 LIR_Opr _index;
263 LIR_Opr _value;
264 LIR_Opr _scratch_reg;
265 CodeEmitInfo* _info;
266
267 public:
268 StoreFlattenedArrayStub(LIR_Opr array, LIR_Opr index, LIR_Opr value, CodeEmitInfo* info);
269 virtual void emit_code(LIR_Assembler* e);
270 virtual CodeEmitInfo* info() const { return _info; }
271 virtual void visit(LIR_OpVisitState* visitor) {
272 visitor->do_slow_case(_info);
273 visitor->do_input(_array);
274 visitor->do_input(_index);
275 visitor->do_input(_value);
276 if (_scratch_reg != LIR_OprFact::illegalOpr) {
277 visitor->do_temp(_scratch_reg);
278 }
279 }
280 #ifndef PRODUCT
281 virtual void print_name(outputStream* out) const { out->print("StoreFlattenedArrayStub"); }
282 #endif // PRODUCT
283 };
284
285 class SubstitutabilityCheckStub: public CodeStub {
286 private:
287 LIR_Opr _left;
288 LIR_Opr _right;
289 LIR_Opr _scratch_reg;
290 CodeEmitInfo* _info;
291 public:
292 SubstitutabilityCheckStub(LIR_Opr left, LIR_Opr right, CodeEmitInfo* info);
293 virtual void emit_code(LIR_Assembler* e);
294 virtual CodeEmitInfo* info() const { return _info; }
295 virtual void visit(LIR_OpVisitState* visitor) {
296 visitor->do_slow_case(_info);
297 visitor->do_input(_left);
298 visitor->do_input(_right);
299 if (_scratch_reg != LIR_OprFact::illegalOpr) {
300 visitor->do_temp(_scratch_reg);
301 }
302 }
303 #ifndef PRODUCT
304 virtual void print_name(outputStream* out) const { out->print("SubstitutabilityCheckStub"); }
305 #endif // PRODUCT
306 };
307
308 class NewInstanceStub: public CodeStub {
309 private:
310 ciInstanceKlass* _klass;
311 LIR_Opr _klass_reg;
312 LIR_Opr _result;
313 CodeEmitInfo* _info;
314 StubId _stub_id;
315
316 public:
317 NewInstanceStub(LIR_Opr klass_reg, LIR_Opr result, ciInstanceKlass* klass, CodeEmitInfo* info, StubId stub_id);
318 virtual void emit_code(LIR_Assembler* e);
319 virtual CodeEmitInfo* info() const { return _info; }
320 virtual void visit(LIR_OpVisitState* visitor) {
321 visitor->do_slow_case(_info);
322 visitor->do_input(_klass_reg);
323 visitor->do_output(_result);
324 }
325 #ifndef PRODUCT
326 virtual void print_name(outputStream* out) const { out->print("NewInstanceStub"); }
327 #endif // PRODUCT
340 virtual void emit_code(LIR_Assembler* e);
341 virtual CodeEmitInfo* info() const { return _info; }
342 virtual void visit(LIR_OpVisitState* visitor) {
343 visitor->do_slow_case(_info);
344 visitor->do_input(_klass_reg);
345 visitor->do_input(_length);
346 assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
347 }
348 #ifndef PRODUCT
349 virtual void print_name(outputStream* out) const { out->print("NewTypeArrayStub"); }
350 #endif // PRODUCT
351 };
352
353
354 class NewObjectArrayStub: public CodeStub {
355 private:
356 LIR_Opr _klass_reg;
357 LIR_Opr _length;
358 LIR_Opr _result;
359 CodeEmitInfo* _info;
360 bool _is_null_free;
361 public:
362 NewObjectArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info, bool is_null_free);
363 virtual void emit_code(LIR_Assembler* e);
364 virtual CodeEmitInfo* info() const { return _info; }
365 virtual void visit(LIR_OpVisitState* visitor) {
366 visitor->do_slow_case(_info);
367 visitor->do_input(_klass_reg);
368 visitor->do_input(_length);
369 assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
370 }
371 #ifndef PRODUCT
372 virtual void print_name(outputStream* out) const { out->print("NewObjectArrayStub"); }
373 #endif // PRODUCT
374 };
375
376
377 class MonitorAccessStub: public CodeStub {
378 protected:
379 LIR_Opr _obj_reg;
380 LIR_Opr _lock_reg;
381
382 public:
383 MonitorAccessStub(LIR_Opr obj_reg, LIR_Opr lock_reg) {
384 _obj_reg = obj_reg;
385 _lock_reg = lock_reg;
386 }
387
388 #ifndef PRODUCT
389 virtual void print_name(outputStream* out) const { out->print("MonitorAccessStub"); }
390 #endif // PRODUCT
391 };
392
393
394 class MonitorEnterStub: public MonitorAccessStub {
395 private:
396 CodeEmitInfo* _info;
397 CodeStub* _throw_ie_stub;
398 LIR_Opr _scratch_reg;
399
400 public:
401 MonitorEnterStub(LIR_Opr obj_reg, LIR_Opr lock_reg, CodeEmitInfo* info,
402 CodeStub* throw_ie_stub = nullptr, LIR_Opr scratch_reg = LIR_OprFact::illegalOpr)
403 : MonitorAccessStub(obj_reg, lock_reg) {
404 _info = new CodeEmitInfo(info);
405 _scratch_reg = scratch_reg;
406 _throw_ie_stub = throw_ie_stub;
407 if (_throw_ie_stub != nullptr) {
408 assert(_scratch_reg != LIR_OprFact::illegalOpr, "must be");
409 }
410 FrameMap* f = Compilation::current()->frame_map();
411 f->update_reserved_argument_area_size(2 * BytesPerWord);
412 }
413
414 virtual void emit_code(LIR_Assembler* e);
415 virtual CodeEmitInfo* info() const { return _info; }
416 virtual void visit(LIR_OpVisitState* visitor) {
417 visitor->do_input(_obj_reg);
418 visitor->do_input(_lock_reg);
419 if (_scratch_reg != LIR_OprFact::illegalOpr) {
420 visitor->do_temp(_scratch_reg);
421 }
422 visitor->do_slow_case(_info);
423 }
424 #ifndef PRODUCT
425 virtual void print_name(outputStream* out) const { out->print("MonitorEnterStub"); }
426 #endif // PRODUCT
427 };
428
429
430 class MonitorExitStub: public MonitorAccessStub {
431 private:
432 int _monitor_ix;
433
434 public:
435 MonitorExitStub(LIR_Opr lock_reg, int monitor_ix)
436 : MonitorAccessStub(LIR_OprFact::illegalOpr, lock_reg),
437 _monitor_ix(monitor_ix) { }
438 virtual void emit_code(LIR_Assembler* e);
439 virtual void visit(LIR_OpVisitState* visitor) {
440 assert(_obj_reg->is_illegal(), "unused");
441 visitor->do_temp(_lock_reg);
|