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