1 /*
   2  * Copyright (c) 1999, 2019, 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_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   // For ArrayIndexOutOfBoundsException.
 155   RangeCheckStub(CodeEmitInfo* info, LIR_Opr index, LIR_Opr array);
 156   // For IndexOutOfBoundsException.
 157   RangeCheckStub(CodeEmitInfo* info, LIR_Opr index);
 158   virtual void emit_code(LIR_Assembler* e);
 159   virtual CodeEmitInfo* info() const             { return _info; }
 160   virtual bool is_exception_throw_stub() const   { return true; }
 161   virtual bool is_range_check_stub() const       { return true; }
 162   virtual void visit(LIR_OpVisitState* visitor) {
 163     visitor->do_slow_case(_info);
 164     visitor->do_input(_index);
 165     if (_array) { visitor->do_input(_array); }
 166   }
 167 #ifndef PRODUCT
 168   virtual void print_name(outputStream* out) const { out->print("RangeCheckStub"); }
 169 #endif // PRODUCT
 170 };
 171 
 172 // stub used when predicate fails and deoptimization is needed
 173 class PredicateFailedStub: public CodeStub {
 174  private:
 175   CodeEmitInfo* _info;
 176 
 177  public:
 178   PredicateFailedStub(CodeEmitInfo* info);
 179   virtual void emit_code(LIR_Assembler* e);
 180   virtual CodeEmitInfo* info() const             { return _info; }
 181   virtual void visit(LIR_OpVisitState* visitor) {
 182     visitor->do_slow_case(_info);
 183   }
 184 #ifndef PRODUCT
 185   virtual void print_name(outputStream* out) const { out->print("PredicateFailedStub"); }
 186 #endif // PRODUCT
 187 };
 188 
 189 class DivByZeroStub: public CodeStub {
 190  private:
 191   CodeEmitInfo* _info;
 192   int           _offset;
 193 
 194  public:
 195   DivByZeroStub(CodeEmitInfo* info)
 196     : _info(info), _offset(-1) {
 197   }
 198   DivByZeroStub(int offset, CodeEmitInfo* info)
 199     : _info(info), _offset(offset) {
 200   }
 201   virtual void emit_code(LIR_Assembler* e);
 202   virtual CodeEmitInfo* info() const             { return _info; }
 203   virtual bool is_exception_throw_stub() const   { return true; }
 204   virtual bool is_divbyzero_stub() const         { return true; }
 205   virtual void visit(LIR_OpVisitState* visitor) {
 206     visitor->do_slow_case(_info);
 207   }
 208 #ifndef PRODUCT
 209   virtual void print_name(outputStream* out) const { out->print("DivByZeroStub"); }
 210 #endif // PRODUCT
 211 };
 212 
 213 
 214 class ImplicitNullCheckStub: public CodeStub {
 215  private:
 216   CodeEmitInfo* _info;
 217   int           _offset;
 218 
 219  public:
 220   ImplicitNullCheckStub(int offset, CodeEmitInfo* info)
 221     : _info(info), _offset(offset) {
 222   }
 223   virtual void emit_code(LIR_Assembler* e);
 224   virtual CodeEmitInfo* info() const             { return _info; }
 225   virtual bool is_exception_throw_stub() const   { return true; }
 226   virtual void visit(LIR_OpVisitState* visitor) {
 227     visitor->do_slow_case(_info);
 228   }
 229 #ifndef PRODUCT
 230   virtual void print_name(outputStream* out) const { out->print("ImplicitNullCheckStub"); }
 231 #endif // PRODUCT
 232 };
 233 
 234 class LoadFlattenedArrayStub: public CodeStub {
 235  private:
 236   LIR_Opr          _array;
 237   LIR_Opr          _index;
 238   LIR_Opr          _result;
 239   CodeEmitInfo*    _info;
 240 
 241  public:
 242   LoadFlattenedArrayStub(LIR_Opr array, LIR_Opr index, LIR_Opr result, CodeEmitInfo* info);
 243   virtual void emit_code(LIR_Assembler* e);
 244   virtual CodeEmitInfo* info() const             { return _info; }
 245   virtual void visit(LIR_OpVisitState* visitor) {
 246     visitor->do_slow_case(_info);
 247     visitor->do_input(_array);
 248     visitor->do_input(_index);
 249     visitor->do_output(_result);
 250   }
 251 #ifndef PRODUCT
 252   virtual void print_name(outputStream* out) const { out->print("LoadFlattenedArrayStub"); }
 253 #endif // PRODUCT
 254 };
 255 
 256 
 257 
 258 class NewInstanceStub: public CodeStub {
 259  private:
 260   ciInstanceKlass* _klass;
 261   LIR_Opr          _klass_reg;
 262   LIR_Opr          _result;
 263   CodeEmitInfo*    _info;
 264   Runtime1::StubID _stub_id;
 265 
 266  public:
 267   NewInstanceStub(LIR_Opr klass_reg, LIR_Opr result, ciInstanceKlass* klass, CodeEmitInfo* info, Runtime1::StubID stub_id);
 268   virtual void emit_code(LIR_Assembler* e);
 269   virtual CodeEmitInfo* info() const             { return _info; }
 270   virtual void visit(LIR_OpVisitState* visitor) {
 271     visitor->do_slow_case(_info);
 272     visitor->do_input(_klass_reg);
 273     visitor->do_output(_result);
 274   }
 275 #ifndef PRODUCT
 276   virtual void print_name(outputStream* out) const { out->print("NewInstanceStub"); }
 277 #endif // PRODUCT
 278 };
 279 
 280 
 281 class NewTypeArrayStub: public CodeStub {
 282  private:
 283   LIR_Opr       _klass_reg;
 284   LIR_Opr       _length;
 285   LIR_Opr       _result;
 286   CodeEmitInfo* _info;
 287 
 288  public:
 289   NewTypeArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info);
 290   virtual void emit_code(LIR_Assembler* e);
 291   virtual CodeEmitInfo* info() const             { return _info; }
 292   virtual void visit(LIR_OpVisitState* visitor) {
 293     visitor->do_slow_case(_info);
 294     visitor->do_input(_klass_reg);
 295     visitor->do_input(_length);
 296     assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
 297   }
 298 #ifndef PRODUCT
 299   virtual void print_name(outputStream* out) const { out->print("NewTypeArrayStub"); }
 300 #endif // PRODUCT
 301 };
 302 
 303 
 304 class NewObjectArrayStub: public CodeStub {
 305  private:
 306   LIR_Opr        _klass_reg;
 307   LIR_Opr        _length;
 308   LIR_Opr        _result;
 309   CodeEmitInfo*  _info;
 310   bool           _is_value_type;
 311  public:
 312   NewObjectArrayStub(LIR_Opr klass_reg, LIR_Opr length, LIR_Opr result, CodeEmitInfo* info, bool is_value_type);
 313   virtual void emit_code(LIR_Assembler* e);
 314   virtual CodeEmitInfo* info() const             { return _info; }
 315   virtual void visit(LIR_OpVisitState* visitor) {
 316     visitor->do_slow_case(_info);
 317     visitor->do_input(_klass_reg);
 318     visitor->do_input(_length);
 319     assert(_result->is_valid(), "must be valid"); visitor->do_output(_result);
 320   }
 321 #ifndef PRODUCT
 322   virtual void print_name(outputStream* out) const { out->print("NewObjectArrayStub"); }
 323 #endif // PRODUCT
 324 };
 325 
 326 
 327 class MonitorAccessStub: public CodeStub {
 328  protected:
 329   LIR_Opr _obj_reg;
 330   LIR_Opr _lock_reg;
 331 
 332  public:
 333   MonitorAccessStub(LIR_Opr obj_reg, LIR_Opr lock_reg) {
 334     _obj_reg  = obj_reg;
 335     _lock_reg  = lock_reg;
 336   }
 337 
 338 #ifndef PRODUCT
 339   virtual void print_name(outputStream* out) const { out->print("MonitorAccessStub"); }
 340 #endif // PRODUCT
 341 };
 342 
 343 
 344 class MonitorEnterStub: public MonitorAccessStub {
 345  private:
 346   CodeEmitInfo* _info;
 347   CodeStub* _throw_imse_stub;
 348   LIR_Opr _scratch_reg;
 349 
 350  public:
 351   MonitorEnterStub(LIR_Opr obj_reg, LIR_Opr lock_reg, CodeEmitInfo* info, CodeStub* throw_imse_stub = NULL, LIR_Opr scratch_reg = LIR_OprFact::illegalOpr);
 352 
 353   virtual void emit_code(LIR_Assembler* e);
 354   virtual CodeEmitInfo* info() const             { return _info; }
 355   virtual void visit(LIR_OpVisitState* visitor) {
 356     visitor->do_input(_obj_reg);
 357     visitor->do_input(_lock_reg);
 358     if (_scratch_reg != LIR_OprFact::illegalOpr) {
 359       visitor->do_temp(_scratch_reg);
 360     }
 361     visitor->do_slow_case(_info);
 362   }
 363 #ifndef PRODUCT
 364   virtual void print_name(outputStream* out) const { out->print("MonitorEnterStub"); }
 365 #endif // PRODUCT
 366 };
 367 
 368 
 369 class MonitorExitStub: public MonitorAccessStub {
 370  private:
 371   bool _compute_lock;
 372   int  _monitor_ix;
 373 
 374  public:
 375   MonitorExitStub(LIR_Opr lock_reg, bool compute_lock, int monitor_ix)
 376     : MonitorAccessStub(LIR_OprFact::illegalOpr, lock_reg),
 377       _compute_lock(compute_lock), _monitor_ix(monitor_ix) { }
 378   virtual void emit_code(LIR_Assembler* e);
 379   virtual void visit(LIR_OpVisitState* visitor) {
 380     assert(_obj_reg->is_illegal(), "unused");
 381     if (_compute_lock) {
 382       visitor->do_temp(_lock_reg);
 383     } else {
 384       visitor->do_input(_lock_reg);
 385     }
 386   }
 387 #ifndef PRODUCT
 388   virtual void print_name(outputStream* out) const { out->print("MonitorExitStub"); }
 389 #endif // PRODUCT
 390 };
 391 
 392 
 393 class PatchingStub: public CodeStub {
 394  public:
 395   enum PatchID {
 396     access_field_id,
 397     load_klass_id,
 398     load_mirror_id,
 399     load_appendix_id
 400   };
 401   enum constants {
 402     patch_info_size = 3
 403   };
 404  private:
 405   PatchID       _id;
 406   address       _pc_start;
 407   int           _bytes_to_copy;
 408   Label         _patched_code_entry;
 409   Label         _patch_site_entry;
 410   Label         _patch_site_continuation;
 411   Register      _obj;
 412   CodeEmitInfo* _info;
 413   int           _index;  // index of the patchable oop or Klass* in nmethod oop or metadata table if needed
 414   static int    _patch_info_offset;
 415 
 416   void align_patch_site(MacroAssembler* masm);
 417 
 418  public:
 419   static int patch_info_offset() { return _patch_info_offset; }
 420 
 421   PatchingStub(MacroAssembler* masm, PatchID id, int index = -1):
 422       _id(id)
 423     , _info(NULL)
 424     , _index(index) {
 425     // force alignment of patch sites so we
 426     // can guarantee atomic writes to the patch site.
 427     align_patch_site(masm);
 428     _pc_start = masm->pc();
 429     masm->bind(_patch_site_entry);
 430   }
 431 
 432   void install(MacroAssembler* masm, LIR_PatchCode patch_code, Register obj, CodeEmitInfo* info) {
 433     _info = info;
 434     _obj = obj;
 435     masm->bind(_patch_site_continuation);
 436     _bytes_to_copy = masm->pc() - pc_start();
 437     if (_id == PatchingStub::access_field_id) {
 438       // embed a fixed offset to handle long patches which need to be offset by a word.
 439       // the patching code will just add the field offset field to this offset so
 440       // that we can refernce either the high or low word of a double word field.
 441       int field_offset = 0;
 442       switch (patch_code) {
 443       case lir_patch_low:         field_offset = lo_word_offset_in_bytes; break;
 444       case lir_patch_high:        field_offset = hi_word_offset_in_bytes; break;
 445       case lir_patch_normal:      field_offset = 0;                       break;
 446       default: ShouldNotReachHere();
 447       }
 448       NativeMovRegMem* n_move = nativeMovRegMem_at(pc_start());
 449       n_move->set_offset(field_offset);
 450     } else if (_id == load_klass_id || _id == load_mirror_id || _id == load_appendix_id) {
 451       assert(_obj != noreg, "must have register object for load_klass/load_mirror");
 452 #ifdef ASSERT
 453       // verify that we're pointing at a NativeMovConstReg
 454       nativeMovConstReg_at(pc_start());
 455 #endif
 456     } else {
 457       ShouldNotReachHere();
 458     }
 459     assert(_bytes_to_copy <= (masm->pc() - pc_start()), "not enough bytes");
 460   }
 461 
 462   address pc_start() const                       { return _pc_start; }
 463   PatchID id() const                             { return _id; }
 464 
 465   virtual void emit_code(LIR_Assembler* e);
 466   virtual CodeEmitInfo* info() const             { return _info; }
 467   virtual void visit(LIR_OpVisitState* visitor) {
 468     visitor->do_slow_case(_info);
 469   }
 470 #ifndef PRODUCT
 471   virtual void print_name(outputStream* out) const { out->print("PatchingStub"); }
 472 #endif // PRODUCT
 473 };
 474 
 475 
 476 //------------------------------------------------------------------------------
 477 // DeoptimizeStub
 478 //
 479 class DeoptimizeStub : public CodeStub {
 480 private:
 481   CodeEmitInfo* _info;
 482   jint _trap_request;
 483 
 484 public:
 485   DeoptimizeStub(CodeEmitInfo* info, Deoptimization::DeoptReason reason, Deoptimization::DeoptAction action) :
 486     _info(new CodeEmitInfo(info)), _trap_request(Deoptimization::make_trap_request(reason, action)) {}
 487 
 488   virtual void emit_code(LIR_Assembler* e);
 489   virtual CodeEmitInfo* info() const           { return _info; }
 490   virtual bool is_exception_throw_stub() const { return true; }
 491   virtual void visit(LIR_OpVisitState* visitor) {
 492     visitor->do_slow_case(_info);
 493   }
 494 #ifndef PRODUCT
 495   virtual void print_name(outputStream* out) const { out->print("DeoptimizeStub"); }
 496 #endif // PRODUCT
 497 };
 498 
 499 
 500 class SimpleExceptionStub: public CodeStub {
 501  private:
 502   LIR_Opr          _obj;
 503   Runtime1::StubID _stub;
 504   CodeEmitInfo*    _info;
 505 
 506  public:
 507   SimpleExceptionStub(Runtime1::StubID stub, LIR_Opr obj, CodeEmitInfo* info):
 508     _obj(obj), _stub(stub), _info(info) {
 509   }
 510 
 511   void set_obj(LIR_Opr obj) {
 512     _obj = obj;
 513   }
 514 
 515   virtual void emit_code(LIR_Assembler* e);
 516   virtual CodeEmitInfo* info() const             { return _info; }
 517   virtual bool is_exception_throw_stub() const   { return true; }
 518   virtual bool is_simple_exception_stub() const  { return true; }
 519   virtual void visit(LIR_OpVisitState* visitor) {
 520     if (_obj->is_valid()) visitor->do_input(_obj);
 521     visitor->do_slow_case(_info);
 522   }
 523 #ifndef PRODUCT
 524   virtual void print_name(outputStream* out) const { out->print("SimpleExceptionStub"); }
 525 #endif // PRODUCT
 526 };
 527 
 528 
 529 
 530 class ArrayStoreExceptionStub: public SimpleExceptionStub {
 531  private:
 532   CodeEmitInfo* _info;
 533 
 534  public:
 535   ArrayStoreExceptionStub(LIR_Opr obj, CodeEmitInfo* info): SimpleExceptionStub(Runtime1::throw_array_store_exception_id, obj, info) {}
 536 #ifndef PRODUCT
 537   virtual void print_name(outputStream* out) const { out->print("ArrayStoreExceptionStub"); }
 538 #endif // PRODUCT
 539 };
 540 
 541 
 542 class ArrayCopyStub: public CodeStub {
 543  private:
 544   LIR_OpArrayCopy* _op;
 545 
 546  public:
 547   ArrayCopyStub(LIR_OpArrayCopy* op): _op(op) { }
 548 
 549   LIR_Opr src() const                         { return _op->src(); }
 550   LIR_Opr src_pos() const                     { return _op->src_pos(); }
 551   LIR_Opr dst() const                         { return _op->dst(); }
 552   LIR_Opr dst_pos() const                     { return _op->dst_pos(); }
 553   LIR_Opr length() const                      { return _op->length(); }
 554   LIR_Opr tmp() const                         { return _op->tmp(); }
 555 
 556   virtual void emit_code(LIR_Assembler* e);
 557   virtual CodeEmitInfo* info() const          { return _op->info(); }
 558   virtual void visit(LIR_OpVisitState* visitor) {
 559     // don't pass in the code emit info since it's processed in the fast path
 560     visitor->do_slow_case();
 561   }
 562 #ifndef PRODUCT
 563   virtual void print_name(outputStream* out) const { out->print("ArrayCopyStub"); }
 564 #endif // PRODUCT
 565 };
 566 
 567 #endif // SHARE_C1_C1_CODESTUBS_HPP