< prev index next >

src/hotspot/share/runtime/frame.cpp

Print this page

  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/moduleEntry.hpp"
  27 #include "code/codeCache.hpp"
  28 #include "code/vmreg.inline.hpp"
  29 #include "compiler/abstractCompiler.hpp"
  30 #include "compiler/disassembler.hpp"
  31 #include "compiler/oopMap.hpp"
  32 #include "gc/shared/collectedHeap.inline.hpp"
  33 #include "interpreter/interpreter.hpp"
  34 #include "interpreter/oopMapCache.hpp"
  35 #include "memory/resourceArea.hpp"
  36 #include "memory/universe.hpp"
  37 #include "oops/markWord.hpp"
  38 #include "oops/method.hpp"
  39 #include "oops/methodData.hpp"
  40 #include "oops/oop.inline.hpp"

  41 #include "oops/verifyOopClosure.hpp"
  42 #include "prims/methodHandles.hpp"
  43 #include "runtime/frame.inline.hpp"
  44 #include "runtime/handles.inline.hpp"
  45 #include "runtime/javaCalls.hpp"
  46 #include "runtime/monitorChunk.hpp"
  47 #include "runtime/os.hpp"
  48 #include "runtime/sharedRuntime.hpp"
  49 #include "runtime/signature.hpp"
  50 #include "runtime/stubCodeGenerator.hpp"
  51 #include "runtime/stubRoutines.hpp"
  52 #include "runtime/thread.inline.hpp"
  53 #include "utilities/debug.hpp"
  54 #include "utilities/decoder.hpp"
  55 #include "utilities/formatBuffer.hpp"



  56 
  57 RegisterMap::RegisterMap(JavaThread *thread, bool update_map, bool process_frames) {
  58   _thread         = thread;
  59   _update_map     = update_map;
  60   _process_frames = process_frames;
  61   clear();
  62   debug_only(_update_for_id = NULL;)
  63 #ifndef PRODUCT
  64   for (int i = 0; i < reg_count ; i++ ) _location[i] = NULL;
  65 #endif /* PRODUCT */
  66 }
  67 
  68 RegisterMap::RegisterMap(const RegisterMap* map) {
  69   assert(map != this, "bad initialization parameter");
  70   assert(map != NULL, "RegisterMap must be present");
  71   _thread                = map->thread();
  72   _update_map            = map->update_map();
  73   _process_frames        = map->process_frames();
  74   _include_argument_oops = map->include_argument_oops();
  75   debug_only(_update_for_id = map->_update_for_id;)

 270     return false;
 271 
 272   return !nm->is_at_poll_return(pc());
 273 }
 274 
 275 void frame::deoptimize(JavaThread* thread) {
 276   assert(thread->frame_anchor()->has_last_Java_frame() &&
 277          thread->frame_anchor()->walkable(), "must be");
 278   // Schedule deoptimization of an nmethod activation with this frame.
 279   assert(_cb != NULL && _cb->is_compiled(), "must be");
 280 
 281   // If the call site is a MethodHandle call site use the MH deopt
 282   // handler.
 283   CompiledMethod* cm = (CompiledMethod*) _cb;
 284   address deopt = cm->is_method_handle_return(pc()) ?
 285                         cm->deopt_mh_handler_begin() :
 286                         cm->deopt_handler_begin();
 287 
 288   // Save the original pc before we patch in the new one
 289   cm->set_original_pc(this, pc());



















 290   patch_pc(thread, deopt);
 291 
 292 #ifdef ASSERT
 293   {
 294     RegisterMap map(thread, false);
 295     frame check = thread->last_frame();
 296     while (id() != check.id()) {
 297       check = check.sender(&map);
 298     }
 299     assert(check.is_deoptimized_frame(), "missed deopt");
 300   }
 301 #endif // ASSERT
 302 }
 303 
 304 frame frame::java_sender() const {
 305   RegisterMap map(JavaThread::current(), false);
 306   frame s;
 307   for (s = sender(&map); !(s.is_java_frame() || s.is_first_frame()); s = s.sender(&map)) ;
 308   guarantee(s.is_java_frame(), "tried to get caller of first java frame");
 309   return s;

 659 }
 660 
 661 
 662 /*
 663   The interpreter_frame_expression_stack_at method in the case of SPARC needs the
 664   max_stack value of the method in order to compute the expression stack address.
 665   It uses the Method* in order to get the max_stack value but during GC this
 666   Method* value saved on the frame is changed by reverse_and_push and hence cannot
 667   be used. So we save the max_stack value in the FrameClosure object and pass it
 668   down to the interpreter_frame_expression_stack_at method
 669 */
 670 class InterpreterFrameClosure : public OffsetClosure {
 671  private:
 672   const frame* _fr;
 673   OopClosure*  _f;
 674   int          _max_locals;
 675   int          _max_stack;
 676 
 677  public:
 678   InterpreterFrameClosure(const frame* fr, int max_locals, int max_stack,
 679                           OopClosure* f) {
 680     _fr         = fr;
 681     _max_locals = max_locals;
 682     _max_stack  = max_stack;
 683     _f          = f;
 684   }
 685 
 686   void offset_do(int offset) {
 687     oop* addr;
 688     if (offset < _max_locals) {
 689       addr = (oop*) _fr->interpreter_frame_local_at(offset);
 690       assert((intptr_t*)addr >= _fr->sp(), "must be inside the frame");
 691       _f->do_oop(addr);


 692     } else {
 693       addr = (oop*) _fr->interpreter_frame_expression_stack_at((offset - _max_locals));
 694       // In case of exceptions, the expression stack is invalid and the esp will be reset to express
 695       // this condition. Therefore, we call f only if addr is 'inside' the stack (i.e., addr >= esp for Intel).
 696       bool in_stack;
 697       if (frame::interpreter_frame_expression_stack_direction() > 0) {
 698         in_stack = (intptr_t*)addr <= _fr->interpreter_frame_tos_address();
 699       } else {
 700         in_stack = (intptr_t*)addr >= _fr->interpreter_frame_tos_address();
 701       }
 702       if (in_stack) {
 703         _f->do_oop(addr);


 704       }
 705     }
 706   }
 707 
 708   int max_locals()  { return _max_locals; }
 709 };
 710 
 711 
 712 class InterpretedArgumentOopFinder: public SignatureIterator {
 713  private:
 714   OopClosure*  _f;             // Closure to invoke
 715   int          _offset;        // TOS-relative offset, decremented with each argument
 716   bool         _has_receiver;  // true if the callee has a receiver
 717   const frame* _fr;
 718 
 719   friend class SignatureIterator;  // so do_parameters_on can call do_type
 720   void do_type(BasicType type) {
 721     _offset -= parameter_type_word_count(type);
 722     if (is_reference_type(type)) oop_offset_do();
 723    }

 858       signature = call.signature();
 859       has_receiver = call.has_receiver();
 860       if (map->include_argument_oops() &&
 861           interpreter_frame_expression_stack_size() > 0) {
 862         ResourceMark rm(thread);  // is this right ???
 863         // we are at a call site & the expression stack is not empty
 864         // => process callee's arguments
 865         //
 866         // Note: The expression stack can be empty if an exception
 867         //       occurred during method resolution/execution. In all
 868         //       cases we empty the expression stack completely be-
 869         //       fore handling the exception (the exception handling
 870         //       code in the interpreter calls a blocking runtime
 871         //       routine which can cause this code to be executed).
 872         //       (was bug gri 7/27/98)
 873         oops_interpreted_arguments_do(signature, has_receiver, f);
 874       }
 875     }
 876   }
 877 
 878   InterpreterFrameClosure blk(this, max_locals, m->max_stack(), f);
 879 
 880   // process locals & expression stack
 881   InterpreterOopMap mask;
 882   if (query_oop_map_cache) {
 883     m->mask_for(bci, &mask);
 884   } else {
 885     OopMapCache::compute_one_oop_map(m, bci, &mask);
 886   }
 887   mask.iterate_oop(&blk);
 888 }
 889 

















 890 
 891 void frame::oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f) const {
 892   InterpretedArgumentOopFinder finder(signature, has_receiver, this, f);
 893   finder.oops_do();
 894 }
 895 
 896 void frame::oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* reg_map,
 897                               DerivedPointerIterationMode derived_mode) const {
 898   assert(_cb != NULL, "sanity check");
 899   if (_cb->oop_maps() != NULL) {
 900     OopMapSet::oops_do(this, reg_map, f, derived_mode);
 901 
 902     // Preserve potential arguments for a callee. We handle this by dispatching
 903     // on the codeblob. For c2i, we do
 904     if (reg_map->include_argument_oops()) {
 905       _cb->preserve_callee_argument_oops(*this, reg_map, f);
 906     }
 907   }
 908   // In cases where perm gen is collected, GC will want to mark
 909   // oops referenced from nmethods active on thread stacks so as to

 917 class CompiledArgumentOopFinder: public SignatureIterator {
 918  protected:
 919   OopClosure*     _f;
 920   int             _offset;        // the current offset, incremented with each argument
 921   bool            _has_receiver;  // true if the callee has a receiver
 922   bool            _has_appendix;  // true if the call has an appendix
 923   frame           _fr;
 924   RegisterMap*    _reg_map;
 925   int             _arg_size;
 926   VMRegPair*      _regs;        // VMReg list of arguments
 927 
 928   friend class SignatureIterator;  // so do_parameters_on can call do_type
 929   void do_type(BasicType type) {
 930     if (is_reference_type(type))  handle_oop_offset();
 931     _offset += parameter_type_word_count(type);
 932   }
 933 
 934   virtual void handle_oop_offset() {
 935     // Extract low order register number from register array.
 936     // In LP64-land, the high-order bits are valid but unhelpful.

 937     VMReg reg = _regs[_offset].first();
 938     oop *loc = _fr.oopmapreg_to_oop_location(reg, _reg_map);
 939     assert(loc != NULL, "missing register map entry");
 940     _f->do_oop(loc);
 941   }
 942 
 943  public:
 944   CompiledArgumentOopFinder(Symbol* signature, bool has_receiver, bool has_appendix, OopClosure* f, frame fr, const RegisterMap* reg_map)
 945     : SignatureIterator(signature) {
 946 
 947     // initialize CompiledArgumentOopFinder
 948     _f         = f;
 949     _offset    = 0;
 950     _has_receiver = has_receiver;
 951     _has_appendix = has_appendix;
 952     _fr        = fr;
 953     _reg_map   = (RegisterMap*)reg_map;
 954     _arg_size  = ArgumentSizeComputer(signature).size() + (has_receiver ? 1 : 0) + (has_appendix ? 1 : 0);
 955 
 956     int arg_size;
 957     _regs = SharedRuntime::find_callee_arguments(signature, has_receiver, has_appendix, &arg_size);
 958     assert(arg_size == _arg_size, "wrong arg size");
 959   }
 960 
 961   void oops_do() {
 962     if (_has_receiver) {
 963       handle_oop_offset();
 964       _offset++;
 965     }
 966     do_parameters_on(this);
 967     if (_has_appendix) {
 968       handle_oop_offset();
 969       _offset++;
 970     }
 971   }
 972 };
 973 
 974 void frame::oops_compiled_arguments_do(Symbol* signature, bool has_receiver, bool has_appendix,
 975                                        const RegisterMap* reg_map, OopClosure* f) const {
 976   ResourceMark rm;
 977   CompiledArgumentOopFinder finder(signature, has_receiver, has_appendix, f, *this, reg_map);
 978   finder.oops_do();

  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/moduleEntry.hpp"
  27 #include "code/codeCache.hpp"
  28 #include "code/vmreg.inline.hpp"
  29 #include "compiler/abstractCompiler.hpp"
  30 #include "compiler/disassembler.hpp"
  31 #include "compiler/oopMap.hpp"
  32 #include "gc/shared/collectedHeap.inline.hpp"
  33 #include "interpreter/interpreter.hpp"
  34 #include "interpreter/oopMapCache.hpp"
  35 #include "memory/resourceArea.hpp"
  36 #include "memory/universe.hpp"
  37 #include "oops/markWord.hpp"
  38 #include "oops/method.hpp"
  39 #include "oops/methodData.hpp"
  40 #include "oops/oop.inline.hpp"
  41 #include "oops/inlineKlass.hpp"
  42 #include "oops/verifyOopClosure.hpp"
  43 #include "prims/methodHandles.hpp"
  44 #include "runtime/frame.inline.hpp"
  45 #include "runtime/handles.inline.hpp"
  46 #include "runtime/javaCalls.hpp"
  47 #include "runtime/monitorChunk.hpp"
  48 #include "runtime/os.hpp"
  49 #include "runtime/sharedRuntime.hpp"
  50 #include "runtime/signature.hpp"
  51 #include "runtime/stubCodeGenerator.hpp"
  52 #include "runtime/stubRoutines.hpp"
  53 #include "runtime/thread.inline.hpp"
  54 #include "utilities/debug.hpp"
  55 #include "utilities/decoder.hpp"
  56 #include "utilities/formatBuffer.hpp"
  57 #ifdef COMPILER1
  58 #include "c1/c1_Runtime1.hpp"
  59 #endif
  60 
  61 RegisterMap::RegisterMap(JavaThread *thread, bool update_map, bool process_frames) {
  62   _thread         = thread;
  63   _update_map     = update_map;
  64   _process_frames = process_frames;
  65   clear();
  66   debug_only(_update_for_id = NULL;)
  67 #ifndef PRODUCT
  68   for (int i = 0; i < reg_count ; i++ ) _location[i] = NULL;
  69 #endif /* PRODUCT */
  70 }
  71 
  72 RegisterMap::RegisterMap(const RegisterMap* map) {
  73   assert(map != this, "bad initialization parameter");
  74   assert(map != NULL, "RegisterMap must be present");
  75   _thread                = map->thread();
  76   _update_map            = map->update_map();
  77   _process_frames        = map->process_frames();
  78   _include_argument_oops = map->include_argument_oops();
  79   debug_only(_update_for_id = map->_update_for_id;)

 274     return false;
 275 
 276   return !nm->is_at_poll_return(pc());
 277 }
 278 
 279 void frame::deoptimize(JavaThread* thread) {
 280   assert(thread->frame_anchor()->has_last_Java_frame() &&
 281          thread->frame_anchor()->walkable(), "must be");
 282   // Schedule deoptimization of an nmethod activation with this frame.
 283   assert(_cb != NULL && _cb->is_compiled(), "must be");
 284 
 285   // If the call site is a MethodHandle call site use the MH deopt
 286   // handler.
 287   CompiledMethod* cm = (CompiledMethod*) _cb;
 288   address deopt = cm->is_method_handle_return(pc()) ?
 289                         cm->deopt_mh_handler_begin() :
 290                         cm->deopt_handler_begin();
 291 
 292   // Save the original pc before we patch in the new one
 293   cm->set_original_pc(this, pc());
 294 
 295 #ifdef COMPILER1
 296   if (cm->is_compiled_by_c1() && cm->method()->has_scalarized_args() &&
 297       pc() < cm->verified_inline_entry_point()) {
 298     // The VEP and VIEP(RO) of C1-compiled methods call into the runtime to buffer scalarized value
 299     // type args. We can't deoptimize at that point because the buffers have not yet been initialized.
 300     // Also, if the method is synchronized, we first need to acquire the lock.
 301     // Don't patch the return pc to delay deoptimization until we enter the method body (the check
 302     // addedin LIRGenerator::do_Base will detect the pending deoptimization by checking the original_pc).
 303 #if defined ASSERT && !defined AARCH64   // Stub call site does not look like NativeCall on AArch64
 304     NativeCall* call = nativeCall_before(this->pc());
 305     address dest = call->destination();
 306     assert(dest == Runtime1::entry_for(Runtime1::buffer_inline_args_no_receiver_id) ||
 307            dest == Runtime1::entry_for(Runtime1::buffer_inline_args_id), "unexpected safepoint in entry point");
 308 #endif
 309     return;
 310   }
 311 #endif
 312 
 313   patch_pc(thread, deopt);
 314 
 315 #ifdef ASSERT
 316   {
 317     RegisterMap map(thread, false);
 318     frame check = thread->last_frame();
 319     while (id() != check.id()) {
 320       check = check.sender(&map);
 321     }
 322     assert(check.is_deoptimized_frame(), "missed deopt");
 323   }
 324 #endif // ASSERT
 325 }
 326 
 327 frame frame::java_sender() const {
 328   RegisterMap map(JavaThread::current(), false);
 329   frame s;
 330   for (s = sender(&map); !(s.is_java_frame() || s.is_first_frame()); s = s.sender(&map)) ;
 331   guarantee(s.is_java_frame(), "tried to get caller of first java frame");
 332   return s;

 682 }
 683 
 684 
 685 /*
 686   The interpreter_frame_expression_stack_at method in the case of SPARC needs the
 687   max_stack value of the method in order to compute the expression stack address.
 688   It uses the Method* in order to get the max_stack value but during GC this
 689   Method* value saved on the frame is changed by reverse_and_push and hence cannot
 690   be used. So we save the max_stack value in the FrameClosure object and pass it
 691   down to the interpreter_frame_expression_stack_at method
 692 */
 693 class InterpreterFrameClosure : public OffsetClosure {
 694  private:
 695   const frame* _fr;
 696   OopClosure*  _f;
 697   int          _max_locals;
 698   int          _max_stack;
 699 
 700  public:
 701   InterpreterFrameClosure(const frame* fr, int max_locals, int max_stack,
 702                           OopClosure* f, BufferedValueClosure* bvt_f) {
 703     _fr         = fr;
 704     _max_locals = max_locals;
 705     _max_stack  = max_stack;
 706     _f          = f;
 707   }
 708 
 709   void offset_do(int offset) {
 710     oop* addr;
 711     if (offset < _max_locals) {
 712       addr = (oop*) _fr->interpreter_frame_local_at(offset);
 713       assert((intptr_t*)addr >= _fr->sp(), "must be inside the frame");
 714       if (_f != NULL) {
 715         _f->do_oop(addr);
 716       }
 717     } else {
 718       addr = (oop*) _fr->interpreter_frame_expression_stack_at((offset - _max_locals));
 719       // In case of exceptions, the expression stack is invalid and the esp will be reset to express
 720       // this condition. Therefore, we call f only if addr is 'inside' the stack (i.e., addr >= esp for Intel).
 721       bool in_stack;
 722       if (frame::interpreter_frame_expression_stack_direction() > 0) {
 723         in_stack = (intptr_t*)addr <= _fr->interpreter_frame_tos_address();
 724       } else {
 725         in_stack = (intptr_t*)addr >= _fr->interpreter_frame_tos_address();
 726       }
 727       if (in_stack) {
 728         if (_f != NULL) {
 729           _f->do_oop(addr);
 730         }
 731       }
 732     }
 733   }
 734 
 735   int max_locals()  { return _max_locals; }
 736 };
 737 
 738 
 739 class InterpretedArgumentOopFinder: public SignatureIterator {
 740  private:
 741   OopClosure*  _f;             // Closure to invoke
 742   int          _offset;        // TOS-relative offset, decremented with each argument
 743   bool         _has_receiver;  // true if the callee has a receiver
 744   const frame* _fr;
 745 
 746   friend class SignatureIterator;  // so do_parameters_on can call do_type
 747   void do_type(BasicType type) {
 748     _offset -= parameter_type_word_count(type);
 749     if (is_reference_type(type)) oop_offset_do();
 750    }

 885       signature = call.signature();
 886       has_receiver = call.has_receiver();
 887       if (map->include_argument_oops() &&
 888           interpreter_frame_expression_stack_size() > 0) {
 889         ResourceMark rm(thread);  // is this right ???
 890         // we are at a call site & the expression stack is not empty
 891         // => process callee's arguments
 892         //
 893         // Note: The expression stack can be empty if an exception
 894         //       occurred during method resolution/execution. In all
 895         //       cases we empty the expression stack completely be-
 896         //       fore handling the exception (the exception handling
 897         //       code in the interpreter calls a blocking runtime
 898         //       routine which can cause this code to be executed).
 899         //       (was bug gri 7/27/98)
 900         oops_interpreted_arguments_do(signature, has_receiver, f);
 901       }
 902     }
 903   }
 904 
 905   InterpreterFrameClosure blk(this, max_locals, m->max_stack(), f, NULL);
 906 
 907   // process locals & expression stack
 908   InterpreterOopMap mask;
 909   if (query_oop_map_cache) {
 910     m->mask_for(bci, &mask);
 911   } else {
 912     OopMapCache::compute_one_oop_map(m, bci, &mask);
 913   }
 914   mask.iterate_oop(&blk);
 915 }
 916 
 917 void frame::buffered_values_interpreted_do(BufferedValueClosure* f) {
 918   assert(is_interpreted_frame(), "Not an interpreted frame");
 919   Thread *thread = Thread::current();
 920   methodHandle m (thread, interpreter_frame_method());
 921   jint      bci = interpreter_frame_bci();
 922 
 923   assert(m->is_method(), "checking frame value");
 924   assert(!m->is_native() && bci >= 0 && bci < m->code_size(),
 925          "invalid bci value");
 926 
 927   InterpreterFrameClosure blk(this, m->max_locals(), m->max_stack(), NULL, f);
 928 
 929   // process locals & expression stack
 930   InterpreterOopMap mask;
 931   m->mask_for(bci, &mask);
 932   mask.iterate_oop(&blk);
 933 }
 934 
 935 void frame::oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f) const {
 936   InterpretedArgumentOopFinder finder(signature, has_receiver, this, f);
 937   finder.oops_do();
 938 }
 939 
 940 void frame::oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* reg_map,
 941                               DerivedPointerIterationMode derived_mode) const {
 942   assert(_cb != NULL, "sanity check");
 943   if (_cb->oop_maps() != NULL) {
 944     OopMapSet::oops_do(this, reg_map, f, derived_mode);
 945 
 946     // Preserve potential arguments for a callee. We handle this by dispatching
 947     // on the codeblob. For c2i, we do
 948     if (reg_map->include_argument_oops()) {
 949       _cb->preserve_callee_argument_oops(*this, reg_map, f);
 950     }
 951   }
 952   // In cases where perm gen is collected, GC will want to mark
 953   // oops referenced from nmethods active on thread stacks so as to

 961 class CompiledArgumentOopFinder: public SignatureIterator {
 962  protected:
 963   OopClosure*     _f;
 964   int             _offset;        // the current offset, incremented with each argument
 965   bool            _has_receiver;  // true if the callee has a receiver
 966   bool            _has_appendix;  // true if the call has an appendix
 967   frame           _fr;
 968   RegisterMap*    _reg_map;
 969   int             _arg_size;
 970   VMRegPair*      _regs;        // VMReg list of arguments
 971 
 972   friend class SignatureIterator;  // so do_parameters_on can call do_type
 973   void do_type(BasicType type) {
 974     if (is_reference_type(type))  handle_oop_offset();
 975     _offset += parameter_type_word_count(type);
 976   }
 977 
 978   virtual void handle_oop_offset() {
 979     // Extract low order register number from register array.
 980     // In LP64-land, the high-order bits are valid but unhelpful.
 981     assert(_offset < _arg_size, "out of bounds");
 982     VMReg reg = _regs[_offset].first();
 983     oop *loc = _fr.oopmapreg_to_oop_location(reg, _reg_map);
 984     assert(loc != NULL, "missing register map entry");
 985     _f->do_oop(loc);
 986   }
 987 
 988  public:
 989   CompiledArgumentOopFinder(Symbol* signature, bool has_receiver, bool has_appendix, OopClosure* f, frame fr, const RegisterMap* reg_map)
 990     : SignatureIterator(signature) {
 991 
 992     // initialize CompiledArgumentOopFinder
 993     _f         = f;
 994     _offset    = 0;
 995     _has_receiver = has_receiver;
 996     _has_appendix = has_appendix;
 997     _fr        = fr;
 998     _reg_map   = (RegisterMap*)reg_map;
 999     _regs = SharedRuntime::find_callee_arguments(signature, has_receiver, has_appendix, &_arg_size);




1000   }
1001 
1002   void oops_do() {
1003     if (_has_receiver) {
1004       handle_oop_offset();
1005       _offset++;
1006     }
1007     do_parameters_on(this);
1008     if (_has_appendix) {
1009       handle_oop_offset();
1010       _offset++;
1011     }
1012   }
1013 };
1014 
1015 void frame::oops_compiled_arguments_do(Symbol* signature, bool has_receiver, bool has_appendix,
1016                                        const RegisterMap* reg_map, OopClosure* f) const {
1017   ResourceMark rm;
1018   CompiledArgumentOopFinder finder(signature, has_receiver, has_appendix, f, *this, reg_map);
1019   finder.oops_do();
< prev index next >