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   LIR_Opr       _array;
 151   bool          _throw_index_out_of_bounds_exception;
 152 
 153  public:
 154   RangeCheckStub(CodeEmitInfo* info, LIR_Opr index, LIR_Opr array);
 155   virtual void emit_code(LIR_Assembler* e);
 156   virtual CodeEmitInfo* info() const             { return _info; }
 157   virtual bool is_exception_throw_stub() const   { return true; }
 158   virtual bool is_range_check_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 bool is_divbyzero_stub() const         { return true; }
 202   virtual void visit(LIR_OpVisitState* visitor) {
 203     visitor->do_slow_case(_info);
 204   }
 205 #ifndef PRODUCT
 206   virtual void print_name(outputStream* out) const { out->print("DivByZeroStub"); }
 207 #endif // PRODUCT
 208 };
 209 
 210 
 211 class ImplicitNullCheckStub: public CodeStub {
 212  private:
 213   CodeEmitInfo* _info;
 214   int           _offset;
 215 
 216  public:
 217   ImplicitNullCheckStub(int offset, CodeEmitInfo* info)
 218     : _offset(offset), _info(info) {
 219   }
 220   virtual void emit_code(LIR_Assembler* e);
 221   virtual CodeEmitInfo* info() const             { return _info; }
 222   virtual bool is_exception_throw_stub() const   { return true; }
 223   virtual void visit(LIR_OpVisitState* visitor) {
 224     visitor->do_slow_case(_info);
 225   }
 226 #ifndef PRODUCT
 227   virtual void print_name(outputStream* out) const { out->print("ImplicitNullCheckStub"); }
 228 #endif // PRODUCT
 229 };
 230 
 231 
 232 class NewInstanceStub: public CodeStub {
 233  private:
 234   ciInstanceKlass* _klass;
 235   LIR_Opr          _klass_reg;
 236   LIR_Opr          _result;
 237   CodeEmitInfo*    _info;
 238   Runtime1::StubID _stub_id;
 239 
 240  public:
 241   NewInstanceStub(LIR_Opr klass_reg, LIR_Opr result, ciInstanceKlass* klass, CodeEmitInfo* info, Runtime1::StubID stub_id);
 242   virtual void emit_code(LIR_Assembler* e);
 243   virtual CodeEmitInfo* info() const             { return _info; }
 244   virtual void visit(LIR_OpVisitState* visitor) {
 245     visitor->do_slow_case(_info);
 246     visitor->do_input(_klass_reg);
 247     visitor->do_output(_result);
 248   }
 249 #ifndef PRODUCT
 250   virtual void print_name(outputStream* out) const { out->print("NewInstanceStub"); }
 251 #endif // PRODUCT
 252 };
 253 
 254 
 255 class NewTypeArrayStub: public CodeStub {
 256  private:
 257   LIR_Opr       _klass_reg;
 258   LIR_Opr       _length;
 259   LIR_Opr       _result;
 260   CodeEmitInfo* _info;
 261 
 262  public:
 263   NewTypeArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info);
 264   virtual void emit_code(LIR_Assembler* e);
 265   virtual CodeEmitInfo* info() const             { return _info; }
 266   virtual void visit(LIR_OpVisitState* visitor) {
 267     visitor->do_slow_case(_info);
 268     visitor->do_input(_klass_reg);
 269     visitor->do_input(_length);
 270     assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
 271   }
 272 #ifndef PRODUCT
 273   virtual void print_name(outputStream* out) const { out->print("NewTypeArrayStub"); }
 274 #endif // PRODUCT
 275 };
 276 
 277 
 278 class NewObjectArrayStub: public CodeStub {
 279  private:
 280   LIR_Opr        _klass_reg;
 281   LIR_Opr        _length;
 282   LIR_Opr        _result;
 283   CodeEmitInfo*  _info;
 284 
 285  public:
 286   NewObjectArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info);
 287   virtual void emit_code(LIR_Assembler* e);
 288   virtual CodeEmitInfo* info() const             { return _info; }
 289   virtual void visit(LIR_OpVisitState* visitor) {
 290     visitor->do_slow_case(_info);
 291     visitor->do_input(_klass_reg);
 292     visitor->do_input(_length);
 293     assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
 294   }
 295 #ifndef PRODUCT
 296   virtual void print_name(outputStream* out) const { out->print("NewObjectArrayStub"); }
 297 #endif // PRODUCT
 298 };
 299 
 300 
 301 class MonitorAccessStub: public CodeStub {
 302  protected:
 303   LIR_Opr _obj_reg;
 304   LIR_Opr _lock_reg;
 305 
 306  public:
 307   MonitorAccessStub(LIR_Opr obj_reg, LIR_Opr lock_reg) {
 308     _obj_reg  = obj_reg;
 309     _lock_reg  = lock_reg;
 310   }
 311 
 312 #ifndef PRODUCT
 313   virtual void print_name(outputStream* out) const { out->print("MonitorAccessStub"); }
 314 #endif // PRODUCT
 315 };
 316 
 317 
 318 class MonitorEnterStub: public MonitorAccessStub {
 319  private:
 320   CodeEmitInfo* _info;
 321 
 322  public:
 323   MonitorEnterStub(LIR_Opr obj_reg, LIR_Opr lock_reg, CodeEmitInfo* info);
 324 
 325   virtual void emit_code(LIR_Assembler* e);
 326   virtual CodeEmitInfo* info() const             { return _info; }
 327   virtual void visit(LIR_OpVisitState* visitor) {
 328     visitor->do_input(_obj_reg);
 329     visitor->do_input(_lock_reg);
 330     visitor->do_slow_case(_info);
 331   }
 332 #ifndef PRODUCT
 333   virtual void print_name(outputStream* out) const { out->print("MonitorEnterStub"); }
 334 #endif // PRODUCT
 335 };
 336 
 337 
 338 class MonitorExitStub: public MonitorAccessStub {
 339  private:
 340   bool _compute_lock;
 341   int  _monitor_ix;
 342 
 343  public:
 344   MonitorExitStub(LIR_Opr lock_reg, bool compute_lock, int monitor_ix)
 345     : MonitorAccessStub(LIR_OprFact::illegalOpr, lock_reg),
 346       _compute_lock(compute_lock), _monitor_ix(monitor_ix) { }
 347   virtual void emit_code(LIR_Assembler* e);
 348   virtual void visit(LIR_OpVisitState* visitor) {
 349     assert(_obj_reg->is_illegal(), "unused");
 350     if (_compute_lock) {
 351       visitor->do_temp(_lock_reg);
 352     } else {
 353       visitor->do_input(_lock_reg);
 354     }
 355   }
 356 #ifndef PRODUCT
 357   virtual void print_name(outputStream* out) const { out->print("MonitorExitStub"); }
 358 #endif // PRODUCT
 359 };
 360 
 361 
 362 class PatchingStub: public CodeStub {
 363  public:
 364   enum PatchID {
 365     access_field_id,
 366     load_klass_id,
 367     load_mirror_id,
 368     load_appendix_id
 369   };
 370   enum constants {
 371     patch_info_size = 3
 372   };
 373  private:
 374   PatchID       _id;
 375   address       _pc_start;
 376   int           _bytes_to_copy;
 377   Label         _patched_code_entry;
 378   Label         _patch_site_entry;
 379   Label         _patch_site_continuation;
 380   Register      _obj;
 381   CodeEmitInfo* _info;
 382   int           _index;  // index of the patchable oop or Klass* in nmethod oop or metadata table if needed
 383   static int    _patch_info_offset;
 384 
 385   void align_patch_site(MacroAssembler* masm);
 386 
 387  public:
 388   static int patch_info_offset() { return _patch_info_offset; }
 389 
 390   PatchingStub(MacroAssembler* masm, PatchID id, int index = -1):
 391       _id(id)
 392     , _info(NULL)
 393     , _index(index) {
 394     if (os::is_MP()) {
 395       // force alignment of patch sites on MP hardware so we
 396       // can guarantee atomic writes to the patch site.
 397       align_patch_site(masm);
 398     }
 399     _pc_start = masm->pc();
 400     masm->bind(_patch_site_entry);
 401   }
 402 
 403   void install(MacroAssembler* masm, LIR_PatchCode patch_code, Register obj, CodeEmitInfo* info) {
 404     _info = info;
 405     _obj = obj;
 406     masm->bind(_patch_site_continuation);
 407     _bytes_to_copy = masm->pc() - pc_start();
 408     if (_id == PatchingStub::access_field_id) {
 409       // embed a fixed offset to handle long patches which need to be offset by a word.
 410       // the patching code will just add the field offset field to this offset so
 411       // that we can refernce either the high or low word of a double word field.
 412       int field_offset = 0;
 413       switch (patch_code) {
 414       case lir_patch_low:         field_offset = lo_word_offset_in_bytes; break;
 415       case lir_patch_high:        field_offset = hi_word_offset_in_bytes; break;
 416       case lir_patch_normal:      field_offset = 0;                       break;
 417       default: ShouldNotReachHere();
 418       }
 419       NativeMovRegMem* n_move = nativeMovRegMem_at(pc_start());
 420       n_move->set_offset(field_offset);
 421     } else if (_id == load_klass_id || _id == load_mirror_id || _id == load_appendix_id) {
 422       assert(_obj != noreg, "must have register object for load_klass/load_mirror");
 423 #ifdef ASSERT
 424       // verify that we're pointing at a NativeMovConstReg
 425       nativeMovConstReg_at(pc_start());
 426 #endif
 427     } else {
 428       ShouldNotReachHere();
 429     }
 430     assert(_bytes_to_copy <= (masm->pc() - pc_start()), "not enough bytes");
 431   }
 432 
 433   address pc_start() const                       { return _pc_start; }
 434   PatchID id() const                             { return _id; }
 435 
 436   virtual void emit_code(LIR_Assembler* e);
 437   virtual CodeEmitInfo* info() const             { return _info; }
 438   virtual void visit(LIR_OpVisitState* visitor) {
 439     visitor->do_slow_case(_info);
 440   }
 441 #ifndef PRODUCT
 442   virtual void print_name(outputStream* out) const { out->print("PatchingStub"); }
 443 #endif // PRODUCT
 444 };
 445 
 446 
 447 //------------------------------------------------------------------------------
 448 // DeoptimizeStub
 449 //
 450 class DeoptimizeStub : public CodeStub {
 451 private:
 452   CodeEmitInfo* _info;
 453   jint _trap_request;
 454 
 455 public:
 456   DeoptimizeStub(CodeEmitInfo* info, Deoptimization::DeoptReason reason, Deoptimization::DeoptAction action) :
 457     _info(new CodeEmitInfo(info)), _trap_request(Deoptimization::make_trap_request(reason, action)) {}
 458 
 459   virtual void emit_code(LIR_Assembler* e);
 460   virtual CodeEmitInfo* info() const           { return _info; }
 461   virtual bool is_exception_throw_stub() const { return true; }
 462   virtual void visit(LIR_OpVisitState* visitor) {
 463     visitor->do_slow_case(_info);
 464   }
 465 #ifndef PRODUCT
 466   virtual void print_name(outputStream* out) const { out->print("DeoptimizeStub"); }
 467 #endif // PRODUCT
 468 };
 469 
 470 
 471 class SimpleExceptionStub: public CodeStub {
 472  private:
 473   LIR_Opr          _obj;
 474   Runtime1::StubID _stub;
 475   CodeEmitInfo*    _info;
 476 
 477  public:
 478   SimpleExceptionStub(Runtime1::StubID stub, LIR_Opr obj, CodeEmitInfo* info):
 479     _obj(obj), _info(info), _stub(stub) {
 480   }
 481 
 482   void set_obj(LIR_Opr obj) {
 483     _obj = obj;
 484   }
 485 
 486   virtual void emit_code(LIR_Assembler* e);
 487   virtual CodeEmitInfo* info() const             { return _info; }
 488   virtual bool is_exception_throw_stub() const   { return true; }
 489   virtual bool is_simple_exception_stub() const  { return true; }
 490   virtual void visit(LIR_OpVisitState* visitor) {
 491     if (_obj->is_valid()) visitor->do_input(_obj);
 492     visitor->do_slow_case(_info);
 493   }
 494 #ifndef PRODUCT
 495   virtual void print_name(outputStream* out) const { out->print("SimpleExceptionStub"); }
 496 #endif // PRODUCT
 497 };
 498 
 499 
 500 
 501 class ArrayStoreExceptionStub: public SimpleExceptionStub {
 502  private:
 503   CodeEmitInfo* _info;
 504 
 505  public:
 506   ArrayStoreExceptionStub(LIR_Opr obj, CodeEmitInfo* info): SimpleExceptionStub(Runtime1::throw_array_store_exception_id, obj, info) {}
 507 #ifndef PRODUCT
 508   virtual void print_name(outputStream* out) const { out->print("ArrayStoreExceptionStub"); }
 509 #endif // PRODUCT
 510 };
 511 
 512 
 513 class ArrayCopyStub: public CodeStub {
 514  private:
 515   LIR_OpArrayCopy* _op;
 516 
 517  public:
 518   ArrayCopyStub(LIR_OpArrayCopy* op): _op(op) { }
 519 
 520   LIR_Opr src() const                         { return _op->src(); }
 521   LIR_Opr src_pos() const                     { return _op->src_pos(); }
 522   LIR_Opr dst() const                         { return _op->dst(); }
 523   LIR_Opr dst_pos() const                     { return _op->dst_pos(); }
 524   LIR_Opr length() const                      { return _op->length(); }
 525   LIR_Opr tmp() const                         { return _op->tmp(); }
 526 
 527   virtual void emit_code(LIR_Assembler* e);
 528   virtual CodeEmitInfo* info() const          { return _op->info(); }
 529   virtual void visit(LIR_OpVisitState* visitor) {
 530     // don't pass in the code emit info since it's processed in the fast path
 531     visitor->do_slow_case();
 532   }
 533 #ifndef PRODUCT
 534   virtual void print_name(outputStream* out) const { out->print("ArrayCopyStub"); }
 535 #endif // PRODUCT
 536 };
 537 
 538 //////////////////////////////////////////////////////////////////////////////////////////
 539 #if INCLUDE_ALL_GCS
 540 
 541 // Code stubs for Garbage-First barriers.
 542 class G1PreBarrierStub: public CodeStub {
 543  private:
 544   bool _do_load;
 545   LIR_Opr _addr;
 546   LIR_Opr _pre_val;
 547   LIR_PatchCode _patch_code;
 548   CodeEmitInfo* _info;
 549 
 550  public:
 551   // Version that _does_ generate a load of the previous value from addr.
 552   // addr (the address of the field to be read) must be a LIR_Address
 553   // pre_val (a temporary register) must be a register;
 554   G1PreBarrierStub(LIR_Opr addr, LIR_Opr pre_val, LIR_PatchCode patch_code, CodeEmitInfo* info) :
 555     _addr(addr), _pre_val(pre_val), _do_load(true),
 556     _patch_code(patch_code), _info(info)
 557   {
 558     assert(_pre_val->is_register(), "should be temporary register");
 559     assert(_addr->is_address(), "should be the address of the field");
 560   }
 561 
 562   // Version that _does not_ generate load of the previous value; the
 563   // previous value is assumed to have already been loaded into pre_val.
 564   G1PreBarrierStub(LIR_Opr pre_val) :
 565     _addr(LIR_OprFact::illegalOpr), _pre_val(pre_val), _do_load(false),
 566     _patch_code(lir_patch_none), _info(NULL)
 567   {
 568     assert(_pre_val->is_register(), "should be a register");
 569   }
 570 
 571   LIR_Opr addr() const { return _addr; }
 572   LIR_Opr pre_val() const { return _pre_val; }
 573   LIR_PatchCode patch_code() const { return _patch_code; }
 574   CodeEmitInfo* info() const { return _info; }
 575   bool do_load() const { return _do_load; }
 576 
 577   virtual void emit_code(LIR_Assembler* e);
 578   virtual void visit(LIR_OpVisitState* visitor) {
 579     if (_do_load) {
 580       // don't pass in the code emit info since it's processed in the fast
 581       // path
 582       if (_info != NULL)
 583         visitor->do_slow_case(_info);
 584       else
 585         visitor->do_slow_case();
 586 
 587       visitor->do_input(_addr);
 588       visitor->do_temp(_pre_val);
 589     } else {
 590       visitor->do_slow_case();
 591       visitor->do_input(_pre_val);
 592     }
 593   }
 594 #ifndef PRODUCT
 595   virtual void print_name(outputStream* out) const { out->print("G1PreBarrierStub"); }
 596 #endif // PRODUCT
 597 };
 598 
 599 class G1PostBarrierStub: public CodeStub {
 600  private:
 601   LIR_Opr _addr;
 602   LIR_Opr _new_val;
 603 
 604  public:
 605   // addr (the address of the object head) and new_val must be registers.
 606   G1PostBarrierStub(LIR_Opr addr, LIR_Opr new_val): _addr(addr), _new_val(new_val) { }
 607 
 608   LIR_Opr addr() const { return _addr; }
 609   LIR_Opr new_val() const { return _new_val; }
 610 
 611   virtual void emit_code(LIR_Assembler* e);
 612   virtual void visit(LIR_OpVisitState* visitor) {
 613     // don't pass in the code emit info since it's processed in the fast path
 614     visitor->do_slow_case();
 615     visitor->do_input(_addr);
 616     visitor->do_input(_new_val);
 617   }
 618 #ifndef PRODUCT
 619   virtual void print_name(outputStream* out) const { out->print("G1PostBarrierStub"); }
 620 #endif // PRODUCT
 621 };
 622 
 623 #endif // INCLUDE_ALL_GCS
 624 //////////////////////////////////////////////////////////////////////////////////////////
 625 
 626 #endif // SHARE_VM_C1_C1_CODESTUBS_HPP