1 /*
  2  * Copyright (c) 1999, 2020, 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_IR.hpp"
 30 #include "c1/c1_Instruction.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 NULL; }
 58   virtual bool is_exception_throw_stub() const   { return false; }
 59   virtual bool is_simple_exception_stub() const  { return false; }
 60 #ifndef PRODUCT
 61   virtual void print_name(outputStream* out) const = 0;
 62 #endif
 63 
 64   // label access
 65   Label* entry()                                 { return &_entry; }
 66   Label* continuation()                          { return &_continuation; }
 67   // for LIR
 68   virtual void visit(LIR_OpVisitState* visit) = 0;
 69 };
 70 
 71 class CodeStubList: public GrowableArray<CodeStub*> {
 72  public:
 73   CodeStubList(): GrowableArray<CodeStub*>() {}
 74 
 75   void append(CodeStub* stub) {
 76     if (!contains(stub)) {
 77       GrowableArray<CodeStub*>::append(stub);
 78     }
 79   }
 80 };
 81 
 82 class C1SafepointPollStub: public CodeStub {
 83  private:
 84   uintptr_t _safepoint_offset;
 85 
 86  public:
 87   C1SafepointPollStub() :
 88       _safepoint_offset(0) {
 89   }
 90 
 91   uintptr_t safepoint_offset() { return _safepoint_offset; }
 92   void set_safepoint_offset(uintptr_t safepoint_offset) { _safepoint_offset = safepoint_offset; }
 93 
 94   virtual void emit_code(LIR_Assembler* e);
 95   virtual void visit(LIR_OpVisitState* visitor) {
 96     // don't pass in the code emit info since it's processed in the fast path
 97     visitor->do_slow_case();
 98   }
 99 #ifndef PRODUCT
100   virtual void print_name(outputStream* out) const { out->print("C1SafepointPollStub"); }
101 #endif // PRODUCT
102 };
103 
104 class CounterOverflowStub: public CodeStub {
105  private:
106   CodeEmitInfo* _info;
107   int           _bci;
108   LIR_Opr       _method;
109 
110 public:
111   CounterOverflowStub(CodeEmitInfo* info, int bci, LIR_Opr method) :  _info(info), _bci(bci), _method(method) {
112   }
113 
114   virtual void emit_code(LIR_Assembler* e);
115 
116   virtual void visit(LIR_OpVisitState* visitor) {
117     visitor->do_slow_case(_info);
118     visitor->do_input(_method);
119   }
120 
121 #ifndef PRODUCT
122   virtual void print_name(outputStream* out) const { out->print("CounterOverflowStub"); }
123 #endif // PRODUCT
124 
125 };
126 
127 class ConversionStub: public CodeStub {
128  private:
129   Bytecodes::Code _bytecode;
130   LIR_Opr         _input;
131   LIR_Opr         _result;
132 
133   static float float_zero;
134   static double double_zero;
135  public:
136   ConversionStub(Bytecodes::Code bytecode, LIR_Opr input, LIR_Opr result)
137     : _bytecode(bytecode), _input(input), _result(result) {
138     NOT_IA32( ShouldNotReachHere(); ) // used only on x86-32
139   }
140 
141   Bytecodes::Code bytecode() { return _bytecode; }
142   LIR_Opr         input()    { return _input; }
143   LIR_Opr         result()   { return _result; }
144 
145   virtual void emit_code(LIR_Assembler* e);
146   virtual void visit(LIR_OpVisitState* visitor) {
147     visitor->do_slow_case();
148     visitor->do_input(_input);
149     visitor->do_output(_result);
150   }
151 #ifndef PRODUCT
152   virtual void print_name(outputStream* out) const { out->print("ConversionStub"); }
153 #endif // PRODUCT
154 };
155 
156 
157 // Throws ArrayIndexOutOfBoundsException by default but can be
158 // configured to throw IndexOutOfBoundsException in constructor
159 class RangeCheckStub: public CodeStub {
160  private:
161   CodeEmitInfo* _info;
162   LIR_Opr       _index;
163   LIR_Opr       _array;
164   bool          _throw_index_out_of_bounds_exception;
165 
166  public:
167   // For ArrayIndexOutOfBoundsException.
168   RangeCheckStub(CodeEmitInfo* info, LIR_Opr index, LIR_Opr array);
169   // For IndexOutOfBoundsException.
170   RangeCheckStub(CodeEmitInfo* info, LIR_Opr index);
171   virtual void emit_code(LIR_Assembler* e);
172   virtual CodeEmitInfo* info() const             { return _info; }
173   virtual bool is_exception_throw_stub() const   { return true; }
174   virtual void visit(LIR_OpVisitState* visitor) {
175     visitor->do_slow_case(_info);
176     visitor->do_input(_index);
177     if (_array) { visitor->do_input(_array); }
178   }
179 #ifndef PRODUCT
180   virtual void print_name(outputStream* out) const { out->print("RangeCheckStub"); }
181 #endif // PRODUCT
182 };
183 
184 // stub used when predicate fails and deoptimization is needed
185 class PredicateFailedStub: public CodeStub {
186  private:
187   CodeEmitInfo* _info;
188 
189  public:
190   PredicateFailedStub(CodeEmitInfo* info);
191   virtual void emit_code(LIR_Assembler* e);
192   virtual CodeEmitInfo* info() const             { return _info; }
193   virtual void visit(LIR_OpVisitState* visitor) {
194     visitor->do_slow_case(_info);
195   }
196 #ifndef PRODUCT
197   virtual void print_name(outputStream* out) const { out->print("PredicateFailedStub"); }
198 #endif // PRODUCT
199 };
200 
201 class DivByZeroStub: public CodeStub {
202  private:
203   CodeEmitInfo* _info;
204   int           _offset;
205 
206  public:
207   DivByZeroStub(CodeEmitInfo* info)
208     : _info(info), _offset(-1) {
209   }
210   DivByZeroStub(int offset, CodeEmitInfo* info)
211     : _info(info), _offset(offset) {
212   }
213   virtual void emit_code(LIR_Assembler* e);
214   virtual CodeEmitInfo* info() const             { return _info; }
215   virtual bool is_exception_throw_stub() const   { return true; }
216   virtual void visit(LIR_OpVisitState* visitor) {
217     visitor->do_slow_case(_info);
218   }
219 #ifndef PRODUCT
220   virtual void print_name(outputStream* out) const { out->print("DivByZeroStub"); }
221 #endif // PRODUCT
222 };
223 
224 
225 class ImplicitNullCheckStub: public CodeStub {
226  private:
227   CodeEmitInfo* _info;
228   int           _offset;
229 
230  public:
231   ImplicitNullCheckStub(int offset, CodeEmitInfo* info)
232     : _info(info), _offset(offset) {
233   }
234   virtual void emit_code(LIR_Assembler* e);
235   virtual CodeEmitInfo* info() const             { return _info; }
236   virtual bool is_exception_throw_stub() const   { return true; }
237   virtual void visit(LIR_OpVisitState* visitor) {
238     visitor->do_slow_case(_info);
239   }
240 #ifndef PRODUCT
241   virtual void print_name(outputStream* out) const { out->print("ImplicitNullCheckStub"); }
242 #endif // PRODUCT
243 };
244 
245 
246 class LoadFlattenedArrayStub: public CodeStub {
247  private:
248   LIR_Opr          _array;
249   LIR_Opr          _index;
250   LIR_Opr          _result;
251   LIR_Opr          _scratch_reg;
252   CodeEmitInfo*    _info;
253 
254  public:
255   LoadFlattenedArrayStub(LIR_Opr array, LIR_Opr index, LIR_Opr result, CodeEmitInfo* info);
256   virtual void emit_code(LIR_Assembler* e);
257   virtual CodeEmitInfo* info() const             { return _info; }
258   virtual void visit(LIR_OpVisitState* visitor) {
259     visitor->do_slow_case(_info);
260     visitor->do_input(_array);
261     visitor->do_input(_index);
262     visitor->do_output(_result);
263     if (_scratch_reg != LIR_OprFact::illegalOpr) {
264       visitor->do_temp(_scratch_reg);
265     }
266   }
267 
268 #ifndef PRODUCT
269   virtual void print_name(outputStream* out) const { out->print("LoadFlattenedArrayStub"); }
270 #endif // PRODUCT
271 };
272 
273 
274 class StoreFlattenedArrayStub: public CodeStub {
275  private:
276   LIR_Opr          _array;
277   LIR_Opr          _index;
278   LIR_Opr          _value;
279   LIR_Opr          _scratch_reg;
280   CodeEmitInfo*    _info;
281 
282  public:
283   StoreFlattenedArrayStub(LIR_Opr array, LIR_Opr index, LIR_Opr value, CodeEmitInfo* info);
284   virtual void emit_code(LIR_Assembler* e);
285   virtual CodeEmitInfo* info() const             { return _info; }
286   virtual void visit(LIR_OpVisitState* visitor) {
287     visitor->do_slow_case(_info);
288     visitor->do_input(_array);
289     visitor->do_input(_index);
290     visitor->do_input(_value);
291     if (_scratch_reg != LIR_OprFact::illegalOpr) {
292       visitor->do_temp(_scratch_reg);
293     }
294   }
295 #ifndef PRODUCT
296   virtual void print_name(outputStream* out) const { out->print("StoreFlattenedArrayStub"); }
297 #endif // PRODUCT
298 };
299 
300 class SubstitutabilityCheckStub: public CodeStub {
301  private:
302   LIR_Opr          _left;
303   LIR_Opr          _right;
304   LIR_Opr          _scratch_reg;
305   CodeEmitInfo*    _info;
306  public:
307   SubstitutabilityCheckStub(LIR_Opr left, LIR_Opr right, CodeEmitInfo* info);
308   virtual void emit_code(LIR_Assembler* e);
309   virtual CodeEmitInfo* info() const             { return _info; }
310   virtual void visit(LIR_OpVisitState* visitor) {
311     visitor->do_slow_case(_info);
312     visitor->do_input(_left);
313     visitor->do_input(_right);
314     if (_scratch_reg != LIR_OprFact::illegalOpr) {
315       visitor->do_temp(_scratch_reg);
316     }
317   }
318 #ifndef PRODUCT
319   virtual void print_name(outputStream* out) const { out->print("SubstitutabilityCheckStub"); }
320 #endif // PRODUCT
321 };
322 
323 class NewInstanceStub: public CodeStub {
324  private:
325   ciInstanceKlass* _klass;
326   LIR_Opr          _klass_reg;
327   LIR_Opr          _result;
328   CodeEmitInfo*    _info;
329   Runtime1::StubID _stub_id;
330 
331  public:
332   NewInstanceStub(LIR_Opr klass_reg, LIR_Opr result, ciInstanceKlass* klass, CodeEmitInfo* info, Runtime1::StubID stub_id);
333   virtual void emit_code(LIR_Assembler* e);
334   virtual CodeEmitInfo* info() const             { return _info; }
335   virtual void visit(LIR_OpVisitState* visitor) {
336     visitor->do_slow_case(_info);
337     visitor->do_input(_klass_reg);
338     visitor->do_output(_result);
339   }
340 #ifndef PRODUCT
341   virtual void print_name(outputStream* out) const { out->print("NewInstanceStub"); }
342 #endif // PRODUCT
343 };
344 
345 
346 class NewTypeArrayStub: public CodeStub {
347  private:
348   LIR_Opr       _klass_reg;
349   LIR_Opr       _length;
350   LIR_Opr       _result;
351   CodeEmitInfo* _info;
352 
353  public:
354   NewTypeArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info);
355   virtual void emit_code(LIR_Assembler* e);
356   virtual CodeEmitInfo* info() const             { return _info; }
357   virtual void visit(LIR_OpVisitState* visitor) {
358     visitor->do_slow_case(_info);
359     visitor->do_input(_klass_reg);
360     visitor->do_input(_length);
361     assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
362   }
363 #ifndef PRODUCT
364   virtual void print_name(outputStream* out) const { out->print("NewTypeArrayStub"); }
365 #endif // PRODUCT
366 };
367 
368 
369 class NewObjectArrayStub: public CodeStub {
370  private:
371   LIR_Opr        _klass_reg;
372   LIR_Opr        _length;
373   LIR_Opr        _result;
374   CodeEmitInfo*  _info;
375   bool           _is_null_free;
376  public:
377   NewObjectArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info, bool is_null_free);
378   virtual void emit_code(LIR_Assembler* e);
379   virtual CodeEmitInfo* info() const             { return _info; }
380   virtual void visit(LIR_OpVisitState* visitor) {
381     visitor->do_slow_case(_info);
382     visitor->do_input(_klass_reg);
383     visitor->do_input(_length);
384     assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
385   }
386 #ifndef PRODUCT
387   virtual void print_name(outputStream* out) const { out->print("NewObjectArrayStub"); }
388 #endif // PRODUCT
389 };
390 
391 
392 class MonitorAccessStub: public CodeStub {
393  protected:
394   LIR_Opr _obj_reg;
395   LIR_Opr _lock_reg;
396 
397  public:
398   MonitorAccessStub(LIR_Opr obj_reg, LIR_Opr lock_reg) {
399     _obj_reg  = obj_reg;
400     _lock_reg  = lock_reg;
401   }
402 
403 #ifndef PRODUCT
404   virtual void print_name(outputStream* out) const { out->print("MonitorAccessStub"); }
405 #endif // PRODUCT
406 };
407 
408 
409 class MonitorEnterStub: public MonitorAccessStub {
410  private:
411   CodeEmitInfo* _info;
412   CodeStub* _throw_imse_stub;
413   LIR_Opr _scratch_reg;
414 
415  public:
416   MonitorEnterStub(LIR_Opr obj_reg, LIR_Opr lock_reg, CodeEmitInfo* info, CodeStub* throw_imse_stub = NULL, LIR_Opr scratch_reg = LIR_OprFact::illegalOpr);
417 
418   virtual void emit_code(LIR_Assembler* e);
419   virtual CodeEmitInfo* info() const             { return _info; }
420   virtual void visit(LIR_OpVisitState* visitor) {
421     visitor->do_input(_obj_reg);
422     visitor->do_input(_lock_reg);
423     if (_scratch_reg != LIR_OprFact::illegalOpr) {
424       visitor->do_temp(_scratch_reg);
425     }
426     visitor->do_slow_case(_info);
427   }
428 #ifndef PRODUCT
429   virtual void print_name(outputStream* out) const { out->print("MonitorEnterStub"); }
430 #endif // PRODUCT
431 };
432 
433 
434 class MonitorExitStub: public MonitorAccessStub {
435  private:
436   bool _compute_lock;
437   int  _monitor_ix;
438 
439  public:
440   MonitorExitStub(LIR_Opr lock_reg, bool compute_lock, int monitor_ix)
441     : MonitorAccessStub(LIR_OprFact::illegalOpr, lock_reg),
442       _compute_lock(compute_lock), _monitor_ix(monitor_ix) { }
443   virtual void emit_code(LIR_Assembler* e);
444   virtual void visit(LIR_OpVisitState* visitor) {
445     assert(_obj_reg->is_illegal(), "unused");
446     if (_compute_lock) {
447       visitor->do_temp(_lock_reg);
448     } else {
449       visitor->do_input(_lock_reg);
450     }
451   }
452 #ifndef PRODUCT
453   virtual void print_name(outputStream* out) const { out->print("MonitorExitStub"); }
454 #endif // PRODUCT
455 };
456 
457 
458 class PatchingStub: public CodeStub {
459  public:
460   enum PatchID {
461     access_field_id,
462     load_klass_id,
463     load_mirror_id,
464     load_appendix_id
465   };
466   enum constants {
467     patch_info_size = 3
468   };
469  private:
470   PatchID       _id;
471   address       _pc_start;
472   int           _bytes_to_copy;
473   Label         _patched_code_entry;
474   Label         _patch_site_entry;
475   Label         _patch_site_continuation;
476   Register      _obj;
477   CodeEmitInfo* _info;
478   int           _index;  // index of the patchable oop or Klass* in nmethod or metadata table if needed
479   static int    _patch_info_offset;
480 
481   void align_patch_site(MacroAssembler* masm);
482 
483  public:
484   static int patch_info_offset() { return _patch_info_offset; }
485 
486   PatchingStub(MacroAssembler* masm, PatchID id, int index = -1):
487       _id(id)
488     , _info(NULL)
489     , _index(index) {
490     // force alignment of patch sites so we
491     // can guarantee atomic writes to the patch site.
492     align_patch_site(masm);
493     _pc_start = masm->pc();
494     masm->bind(_patch_site_entry);
495   }
496 
497   void install(MacroAssembler* masm, LIR_PatchCode patch_code, Register obj, CodeEmitInfo* info) {
498     _info = info;
499     _obj = obj;
500     masm->bind(_patch_site_continuation);
501     _bytes_to_copy = masm->pc() - pc_start();
502     if (_id == PatchingStub::access_field_id) {
503       // embed a fixed offset to handle long patches which need to be offset by a word.
504       // the patching code will just add the field offset field to this offset so
505       // that we can reference either the high or low word of a double word field.
506       int field_offset = 0;
507       switch (patch_code) {
508       case lir_patch_low:         field_offset = lo_word_offset_in_bytes; break;
509       case lir_patch_high:        field_offset = hi_word_offset_in_bytes; break;
510       case lir_patch_normal:      field_offset = 0;                       break;
511       default: ShouldNotReachHere();
512       }
513       NativeMovRegMem* n_move = nativeMovRegMem_at(pc_start());
514       n_move->set_offset(field_offset);
515       // Copy will never get executed, so only copy the part which is required for patching.
516       _bytes_to_copy = MAX2(n_move->num_bytes_to_end_of_patch(), (int)NativeGeneralJump::instruction_size);
517     } else if (_id == load_klass_id || _id == load_mirror_id || _id == load_appendix_id) {
518       assert(_obj != noreg, "must have register object for load_klass/load_mirror");
519 #ifdef ASSERT
520       // verify that we're pointing at a NativeMovConstReg
521       nativeMovConstReg_at(pc_start());
522 #endif
523     } else {
524       ShouldNotReachHere();
525     }
526     assert(_bytes_to_copy <= (masm->pc() - pc_start()), "not enough bytes");
527   }
528 
529   address pc_start() const                       { return _pc_start; }
530   PatchID id() const                             { return _id; }
531 
532   virtual void emit_code(LIR_Assembler* e);
533   virtual CodeEmitInfo* info() const             { return _info; }
534   virtual void visit(LIR_OpVisitState* visitor) {
535     visitor->do_slow_case(_info);
536   }
537 #ifndef PRODUCT
538   virtual void print_name(outputStream* out) const { out->print("PatchingStub"); }
539 #endif // PRODUCT
540 };
541 
542 
543 //------------------------------------------------------------------------------
544 // DeoptimizeStub
545 //
546 class DeoptimizeStub : public CodeStub {
547 private:
548   CodeEmitInfo* _info;
549   jint _trap_request;
550 
551 public:
552   DeoptimizeStub(CodeEmitInfo* info, Deoptimization::DeoptReason reason, Deoptimization::DeoptAction action) :
553     _info(new CodeEmitInfo(info)), _trap_request(Deoptimization::make_trap_request(reason, action)) {}
554 
555   virtual void emit_code(LIR_Assembler* e);
556   virtual CodeEmitInfo* info() const           { return _info; }
557   virtual bool is_exception_throw_stub() const { return true; }
558   virtual void visit(LIR_OpVisitState* visitor) {
559     visitor->do_slow_case(_info);
560   }
561 #ifndef PRODUCT
562   virtual void print_name(outputStream* out) const { out->print("DeoptimizeStub"); }
563 #endif // PRODUCT
564 };
565 
566 
567 class SimpleExceptionStub: public CodeStub {
568  private:
569   LIR_Opr          _obj;
570   Runtime1::StubID _stub;
571   CodeEmitInfo*    _info;
572 
573  public:
574   SimpleExceptionStub(Runtime1::StubID stub, LIR_Opr obj, CodeEmitInfo* info):
575     _obj(obj), _stub(stub), _info(info) {
576   }
577 
578   void set_obj(LIR_Opr obj) {
579     _obj = obj;
580   }
581 
582   virtual void emit_code(LIR_Assembler* e);
583   virtual CodeEmitInfo* info() const             { return _info; }
584   virtual bool is_exception_throw_stub() const   { return true; }
585   virtual bool is_simple_exception_stub() const  { return true; }
586   virtual void visit(LIR_OpVisitState* visitor) {
587     if (_obj->is_valid()) visitor->do_input(_obj);
588     visitor->do_slow_case(_info);
589   }
590 #ifndef PRODUCT
591   virtual void print_name(outputStream* out) const { out->print("SimpleExceptionStub"); }
592 #endif // PRODUCT
593 };
594 
595 
596 
597 class ArrayStoreExceptionStub: public SimpleExceptionStub {
598  private:
599   CodeEmitInfo* _info;
600 
601  public:
602   ArrayStoreExceptionStub(LIR_Opr obj, CodeEmitInfo* info): SimpleExceptionStub(Runtime1::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 
616   LIR_Opr src() const                         { return _op->src(); }
617   LIR_Opr src_pos() const                     { return _op->src_pos(); }
618   LIR_Opr dst() const                         { return _op->dst(); }
619   LIR_Opr dst_pos() const                     { return _op->dst_pos(); }
620   LIR_Opr length() const                      { return _op->length(); }
621   LIR_Opr tmp() const                         { return _op->tmp(); }
622 
623   virtual void emit_code(LIR_Assembler* e);
624   virtual CodeEmitInfo* info() const          { return _op->info(); }
625   virtual void visit(LIR_OpVisitState* visitor) {
626     // don't pass in the code emit info since it's processed in the fast path
627     visitor->do_slow_case();
628   }
629 #ifndef PRODUCT
630   virtual void print_name(outputStream* out) const { out->print("ArrayCopyStub"); }
631 #endif // PRODUCT
632 };
633 
634 #endif // SHARE_C1_C1_CODESTUBS_HPP