1 /*
  2  * Copyright (c) 1999, 2026, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_C1_C1_CODESTUBS_HPP
 26 #define SHARE_C1_C1_CODESTUBS_HPP
 27 
 28 #include "c1/c1_FrameMap.hpp"
 29 #include "c1/c1_Instruction.hpp"
 30 #include "c1/c1_IR.hpp"
 31 #include "c1/c1_LIR.hpp"
 32 #include "c1/c1_Runtime1.hpp"
 33 #include "code/nativeInst.hpp"
 34 #include "utilities/growableArray.hpp"
 35 #include "utilities/macros.hpp"
 36 
 37 class CodeEmitInfo;
 38 class LIR_Assembler;
 39 class LIR_OpVisitState;
 40 
 41 // CodeStubs are little 'out-of-line' pieces of code that
 42 // usually handle slow cases of operations. All code stubs
 43 // are collected and code is emitted at the end of the
 44 // nmethod.
 45 
 46 class CodeStub: public CompilationResourceObj {
 47  protected:
 48   Label _entry;                                  // label at the stub entry point
 49   Label _continuation;                           // label where stub continues, if any
 50 
 51  public:
 52   CodeStub() {}
 53 
 54   // code generation
 55   void assert_no_unbound_labels()                { assert(!_entry.is_unbound() && !_continuation.is_unbound(), "unbound label"); }
 56   virtual void emit_code(LIR_Assembler* e) = 0;
 57   virtual CodeEmitInfo* info() const             { return nullptr; }
 58   virtual bool is_exception_throw_stub() const   { return false; }
 59   virtual bool is_simple_exception_stub() const  { return false; }
 60   virtual int nr_immediate_oops_patched() const  { return 0; }
 61 #ifndef PRODUCT
 62   virtual void print_name(outputStream* out) const = 0;
 63 #endif
 64 
 65   // label access
 66   Label* entry()                                 { return &_entry; }
 67   Label* continuation()                          { return &_continuation; }
 68   // for LIR
 69   virtual void visit(LIR_OpVisitState* visit) = 0;
 70 };
 71 
 72 class CodeStubList: public GrowableArray<CodeStub*> {
 73  public:
 74   CodeStubList(): GrowableArray<CodeStub*>() {}
 75 
 76   void append(CodeStub* stub) {
 77     if (!contains(stub)) {
 78       GrowableArray<CodeStub*>::append(stub);
 79     }
 80   }
 81 };
 82 
 83 class C1SafepointPollStub: public CodeStub {
 84  private:
 85   uintptr_t _safepoint_offset;
 86 
 87  public:
 88   C1SafepointPollStub() :
 89       _safepoint_offset(0) {
 90   }
 91 
 92   uintptr_t safepoint_offset() { return _safepoint_offset; }
 93   void set_safepoint_offset(uintptr_t safepoint_offset) { _safepoint_offset = safepoint_offset; }
 94 
 95   virtual void emit_code(LIR_Assembler* e);
 96   virtual void visit(LIR_OpVisitState* visitor) {
 97     // don't pass in the code emit info since it's processed in the fast path
 98     visitor->do_slow_case();
 99   }
100 #ifndef PRODUCT
101   virtual void print_name(outputStream* out) const { out->print("C1SafepointPollStub"); }
102 #endif // PRODUCT
103 };
104 
105 class CounterOverflowStub: public CodeStub {
106  private:
107   CodeEmitInfo* _info;
108   int           _bci;
109   LIR_Opr       _method;
110 
111 public:
112   CounterOverflowStub(CodeEmitInfo* info, int bci, LIR_Opr method) :  _info(info), _bci(bci), _method(method) {
113     FrameMap* f = Compilation::current()->frame_map();
114     f->update_reserved_argument_area_size(2 * BytesPerWord);
115   }
116 
117   virtual void emit_code(LIR_Assembler* e);
118 
119   virtual void visit(LIR_OpVisitState* visitor) {
120     visitor->do_slow_case(_info);
121     visitor->do_input(_method);
122   }
123 
124 #ifndef PRODUCT
125   virtual void print_name(outputStream* out) const { out->print("CounterOverflowStub"); }
126 #endif // PRODUCT
127 
128 };
129 
130 // Throws ArrayIndexOutOfBoundsException by default but can be
131 // configured to throw IndexOutOfBoundsException in constructor
132 class RangeCheckStub: public CodeStub {
133  private:
134   CodeEmitInfo* _info;
135   LIR_Opr       _index;
136   LIR_Opr       _array;
137   bool          _throw_index_out_of_bounds_exception;
138 
139  public:
140   // For ArrayIndexOutOfBoundsException.
141   RangeCheckStub(CodeEmitInfo* info, LIR_Opr index, LIR_Opr array)
142     : _index(index), _array(array), _throw_index_out_of_bounds_exception(false) {
143     assert(info != nullptr, "must have info");
144     _info = new CodeEmitInfo(info);
145     FrameMap* f = Compilation::current()->frame_map();
146     f->update_reserved_argument_area_size(2 * BytesPerWord);
147   }
148   // For IndexOutOfBoundsException.
149   RangeCheckStub(CodeEmitInfo* info, LIR_Opr index)
150     : _index(index), _array(), _throw_index_out_of_bounds_exception(true) {
151     assert(info != nullptr, "must have info");
152     _info = new CodeEmitInfo(info);
153     FrameMap* f = Compilation::current()->frame_map();
154     f->update_reserved_argument_area_size(2 * BytesPerWord);
155   }
156   virtual void emit_code(LIR_Assembler* e);
157   virtual CodeEmitInfo* info() const             { return _info; }
158   virtual bool is_exception_throw_stub() const   { return true; }
159   virtual void visit(LIR_OpVisitState* visitor) {
160     visitor->do_slow_case(_info);
161     visitor->do_input(_index);
162     if (_array) { visitor->do_input(_array); }
163   }
164 #ifndef PRODUCT
165   virtual void print_name(outputStream* out) const { out->print("RangeCheckStub"); }
166 #endif // PRODUCT
167 };
168 
169 // stub used when predicate fails and deoptimization is needed
170 class PredicateFailedStub: public CodeStub {
171  private:
172   CodeEmitInfo* _info;
173 
174  public:
175   PredicateFailedStub(CodeEmitInfo* info);
176   virtual void emit_code(LIR_Assembler* e);
177   virtual CodeEmitInfo* info() const             { return _info; }
178   virtual void visit(LIR_OpVisitState* visitor) {
179     visitor->do_slow_case(_info);
180   }
181 #ifndef PRODUCT
182   virtual void print_name(outputStream* out) const { out->print("PredicateFailedStub"); }
183 #endif // PRODUCT
184 };
185 
186 class DivByZeroStub: public CodeStub {
187  private:
188   CodeEmitInfo* _info;
189   int           _offset;
190 
191  public:
192   DivByZeroStub(CodeEmitInfo* info)
193     : _info(info), _offset(-1) {
194   }
195   DivByZeroStub(int offset, CodeEmitInfo* info)
196     : _info(info), _offset(offset) {
197   }
198   virtual void emit_code(LIR_Assembler* e);
199   virtual CodeEmitInfo* info() const             { return _info; }
200   virtual bool is_exception_throw_stub() const   { return true; }
201   virtual void visit(LIR_OpVisitState* visitor) {
202     visitor->do_slow_case(_info);
203   }
204 #ifndef PRODUCT
205   virtual void print_name(outputStream* out) const { out->print("DivByZeroStub"); }
206 #endif // PRODUCT
207 };
208 
209 
210 class ImplicitNullCheckStub: public CodeStub {
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
328 };
329 
330 
331 class NewTypeArrayStub: public CodeStub {
332  private:
333   LIR_Opr       _klass_reg;
334   LIR_Opr       _length;
335   LIR_Opr       _result;
336   CodeEmitInfo* _info;
337 
338  public:
339   NewTypeArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info);
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 = false);
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);
442   }
443 #ifndef PRODUCT
444   virtual void print_name(outputStream* out) const { out->print("MonitorExitStub"); }
445 #endif // PRODUCT
446 };
447 
448 
449 class PatchingStub: public CodeStub {
450  public:
451   enum PatchID {
452     access_field_id,
453     load_klass_id,
454     load_mirror_id,
455     load_appendix_id
456   };
457   enum constants {
458     patch_info_size = 3
459   };
460  private:
461   PatchID       _id;
462   address       _pc_start;
463   int           _bytes_to_copy;
464   Label         _patched_code_entry;
465   Label         _patch_site_entry;
466   Label         _patch_site_continuation;
467   Register      _obj;
468   CodeEmitInfo* _info;
469   int           _index;  // index of the patchable oop or Klass* in nmethod or metadata table if needed
470   static int    _patch_info_offset;
471 
472   void align_patch_site(MacroAssembler* masm);
473 
474  public:
475   static int patch_info_offset() { return _patch_info_offset; }
476 
477   PatchingStub(MacroAssembler* masm, PatchID id, int index = -1):
478       _id(id)
479     , _info(nullptr)
480     , _index(index) {
481     // force alignment of patch sites so we
482     // can guarantee atomic writes to the patch site.
483     align_patch_site(masm);
484     _pc_start = masm->pc();
485     masm->bind(_patch_site_entry);
486   }
487 
488   virtual int nr_immediate_oops_patched() const  {
489     if (_id == load_mirror_id || _id == load_appendix_id) {
490       return 1;
491     }
492     return 0;
493   }
494 
495   void install(MacroAssembler* masm, LIR_PatchCode patch_code, Register obj, CodeEmitInfo* info) {
496     _info = info;
497     _obj = obj;
498     masm->bind(_patch_site_continuation);
499     _bytes_to_copy = pointer_delta_as_int(masm->pc(), pc_start());
500     if (_id == PatchingStub::access_field_id) {
501       // embed a fixed offset to handle long patches which need to be offset by a word.
502       // the patching code will just add the field offset field to this offset so
503       // that we can reference either the high or low word of a double word field.
504       int field_offset = 0;
505       switch (patch_code) {
506       case lir_patch_low:         field_offset = lo_word_offset_in_bytes; break;
507       case lir_patch_high:        field_offset = hi_word_offset_in_bytes; break;
508       case lir_patch_normal:      field_offset = 0;                       break;
509       default: ShouldNotReachHere();
510       }
511       NativeMovRegMem* n_move = nativeMovRegMem_at(pc_start());
512       n_move->set_offset(field_offset);
513       // Copy will never get executed, so only copy the part which is required for patching.
514       _bytes_to_copy = MAX2(n_move->num_bytes_to_end_of_patch(), (int)NativeGeneralJump::instruction_size);
515     } else if (_id == load_klass_id || _id == load_mirror_id || _id == load_appendix_id) {
516       assert(_obj != noreg, "must have register object for load_klass/load_mirror");
517 #ifdef ASSERT
518       // verify that we're pointing at a NativeMovConstReg
519       nativeMovConstReg_at(pc_start());
520 #endif
521     } else {
522       ShouldNotReachHere();
523     }
524     assert(_bytes_to_copy <= (masm->pc() - pc_start()), "not enough bytes");
525   }
526 
527   address pc_start() const                       { return _pc_start; }
528   PatchID id() const                             { return _id; }
529 
530   virtual void emit_code(LIR_Assembler* e);
531   virtual CodeEmitInfo* info() const             { return _info; }
532   virtual void visit(LIR_OpVisitState* visitor) {
533     visitor->do_slow_case(_info);
534   }
535 #ifndef PRODUCT
536   virtual void print_name(outputStream* out) const { out->print("PatchingStub"); }
537 #endif // PRODUCT
538 };
539 
540 
541 //------------------------------------------------------------------------------
542 // DeoptimizeStub
543 //
544 class DeoptimizeStub : public CodeStub {
545 private:
546   CodeEmitInfo* _info;
547   jint _trap_request;
548 
549 public:
550   DeoptimizeStub(CodeEmitInfo* info, Deoptimization::DeoptReason reason, Deoptimization::DeoptAction action) :
551     _info(new CodeEmitInfo(info)), _trap_request(Deoptimization::make_trap_request(reason, action)) {
552     FrameMap* f = Compilation::current()->frame_map();
553     f->update_reserved_argument_area_size(2 * BytesPerWord);
554   }
555 
556   virtual void emit_code(LIR_Assembler* e);
557   virtual CodeEmitInfo* info() const           { return _info; }
558   virtual bool is_exception_throw_stub() const { return true; }
559   virtual void visit(LIR_OpVisitState* visitor) {
560     visitor->do_slow_case(_info);
561   }
562 #ifndef PRODUCT
563   virtual void print_name(outputStream* out) const { out->print("DeoptimizeStub"); }
564 #endif // PRODUCT
565 };
566 
567 
568 class SimpleExceptionStub: public CodeStub {
569  private:
570   LIR_Opr          _obj;
571   StubId           _stub;
572   CodeEmitInfo*    _info;
573 
574  public:
575   SimpleExceptionStub(StubId stub, LIR_Opr obj, CodeEmitInfo* info):
576     _obj(obj), _stub(stub), _info(info) {
577     FrameMap* f = Compilation::current()->frame_map();
578     f->update_reserved_argument_area_size(2 * BytesPerWord);
579   }
580 
581   void set_obj(LIR_Opr obj) {
582     _obj = obj;
583   }
584 
585   virtual void emit_code(LIR_Assembler* e);
586   virtual CodeEmitInfo* info() const             { return _info; }
587   virtual bool is_exception_throw_stub() const   { return true; }
588   virtual bool is_simple_exception_stub() const  { return true; }
589   virtual void visit(LIR_OpVisitState* visitor) {
590     if (_obj->is_valid()) visitor->do_input(_obj);
591     visitor->do_slow_case(_info);
592   }
593 #ifndef PRODUCT
594   virtual void print_name(outputStream* out) const { out->print("SimpleExceptionStub"); }
595 #endif // PRODUCT
596 };
597 
598 
599 
600 class ArrayStoreExceptionStub: public SimpleExceptionStub {
601  public:
602   ArrayStoreExceptionStub(LIR_Opr obj, CodeEmitInfo* info): SimpleExceptionStub(StubId::c1_throw_array_store_exception_id, obj, info) {}
603 #ifndef PRODUCT
604   virtual void print_name(outputStream* out) const { out->print("ArrayStoreExceptionStub"); }
605 #endif // PRODUCT
606 };
607 
608 
609 class ArrayCopyStub: public CodeStub {
610  private:
611   LIR_OpArrayCopy* _op;
612 
613  public:
614   ArrayCopyStub(LIR_OpArrayCopy* op): _op(op) {
615     FrameMap* f = Compilation::current()->frame_map();
616     f->update_reserved_argument_area_size(arraycopystub_reserved_argument_area_size * BytesPerWord);
617   }
618 
619   LIR_Opr src() const                         { return _op->src(); }
620   LIR_Opr src_pos() const                     { return _op->src_pos(); }
621   LIR_Opr dst() const                         { return _op->dst(); }
622   LIR_Opr dst_pos() const                     { return _op->dst_pos(); }
623   LIR_Opr length() const                      { return _op->length(); }
624   LIR_Opr tmp() const                         { return _op->tmp(); }
625 
626   virtual void emit_code(LIR_Assembler* e);
627   virtual CodeEmitInfo* info() const          { return _op->info(); }
628   virtual void visit(LIR_OpVisitState* visitor) {
629     // don't pass in the code emit info since it's processed in the fast path
630     visitor->do_slow_case();
631   }
632 #ifndef PRODUCT
633   virtual void print_name(outputStream* out) const { out->print("ArrayCopyStub"); }
634 #endif // PRODUCT
635 };
636 
637 #endif // SHARE_C1_C1_CODESTUBS_HPP
--- EOF ---