< 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;

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


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


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

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

















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

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

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

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

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

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




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