jdk-sandbox: comparison hotspot/src/share/vm/runtime/frame.cpp

equal deleted inserted replaced

-:b363f6ef4068
+:7fc02fbe5c7a
 /*
-* Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 };
 class InterpretedArgumentOopFinder: public SignatureInfo {
 private:
-OopClosure* _f;      // Closure to invoke
+OopClosure* _f;        // Closure to invoke
-int    _offset;      // TOS-relative offset, decremented with each argument
+int    _offset;        // TOS-relative offset, decremented with each argument
-bool   _is_static;   // true if the callee is a static method
+bool   _has_receiver;  // true if the callee has a receiver
 frame* _fr;
 void set(int size, BasicType type) {
 _offset -= size;
 if (type == T_OBJECT || type == T_ARRAY) oop_offset_do();
 addr = (oop*)_fr->interpreter_frame_tos_at(_offset);
 _f->do_oop(addr);
 }
 public:
-InterpretedArgumentOopFinder(symbolHandle signature, bool is_static, frame* fr, OopClosure* f) : SignatureInfo(signature) {
+InterpretedArgumentOopFinder(symbolHandle signature, bool has_receiver, frame* fr, OopClosure* f) : SignatureInfo(signature), _has_receiver(has_receiver) {
 // compute size of arguments
-int args_size = ArgumentSizeComputer(signature).size() + (is_static ? 0 : 1);
+int args_size = ArgumentSizeComputer(signature).size() + (has_receiver ? 1 : 0);
 assert(!fr->is_interpreted_frame() ||
 args_size <= fr->interpreter_frame_expression_stack_size(),
 "args cannot be on stack anymore");
 // initialize InterpretedArgumentOopFinder
 _f         = f;
 _fr        = fr;
 _offset    = args_size;
-_is_static = is_static;
 }
 void oops_do() {
-if (!_is_static) {
+if (_has_receiver) {
 --_offset;
 oop_offset_do();
 }
 iterate_parameters();
 }
 }
 int max_locals = m->is_native() ? m->size_of_parameters() : m->max_locals();
 symbolHandle signature;
-bool is_static = false;
+bool has_receiver = false;
 // Process a callee's arguments if we are at a call site
 // (i.e., if we are at an invoke bytecode)
 // This is used sometimes for calling into the VM, not for another
 // interpreted or compiled frame.
 if (!m->is_native()) {
 Bytecode_invoke *call = Bytecode_invoke_at_check(m, bci);
 if (call != NULL) {
 signature = symbolHandle(thread, call->signature());
-is_static = call->is_invokestatic();
+has_receiver = call->has_receiver();
 if (map->include_argument_oops() &&
 interpreter_frame_expression_stack_size() > 0) {
 ResourceMark rm(thread);  // is this right ???
 // we are at a call site & the expression stack is not empty
 // => process callee's arguments
 //       cases we empty the expression stack completely be-
 //       fore handling the exception (the exception handling
 //       code in the interpreter calls a blocking runtime
 //       routine which can cause this code to be executed).
 //       (was bug gri 7/27/98)
-oops_interpreted_arguments_do(signature, is_static, f);
+oops_interpreted_arguments_do(signature, has_receiver, f);
 }
 }
 }
 if (TaggedStackInterpreter) {
 InterpreterOopMap oopmap_mask;
 OopMapCache::compute_one_oop_map(m, bci, &oopmap_mask);
 mask = &oopmap_mask;
 #endif // ASSERT
 oops_interpreted_locals_do(f, max_locals, mask);
-oops_interpreted_expressions_do(f, signature, is_static,
+oops_interpreted_expressions_do(f, signature, has_receiver,
 m->max_stack(),
 max_locals, mask);
 } else {
 InterpreterFrameClosure blk(this, max_locals, m->max_stack(), f);
 }
 }
 void frame::oops_interpreted_expressions_do(OopClosure *f,
 symbolHandle signature,
-bool is_static,
+bool has_receiver,
 int max_stack,
 int max_locals,
 InterpreterOopMap *mask) {
 // There is no stack no matter what the esp is pointing to (native methods
 // might look like expression stack is nonempty).
 // Point the top of the expression stack above arguments to a call so
 // arguments aren't gc'ed as both stack values for callee and callee
 // arguments in callee's locals.
 int args_size = 0;
 if (!signature.is_null()) {
-args_size = ArgumentSizeComputer(signature).size() + (is_static ? 0 : 1);
+args_size = ArgumentSizeComputer(signature).size() + (has_receiver ? 1 : 0);
 }
 intptr_t *tos_addr = interpreter_frame_tos_at(args_size);
 assert(args_size != 0 || tos_addr == interpreter_frame_tos_address(), "these are same");
 intptr_t *frst_expr = interpreter_frame_expression_stack_at(0);
 #endif // ASSERT
 }
 }
 }
-void frame::oops_interpreted_arguments_do(symbolHandle signature, bool is_static, OopClosure* f) {
+void frame::oops_interpreted_arguments_do(symbolHandle signature, bool has_receiver, OopClosure* f) {
-InterpretedArgumentOopFinder finder(signature, is_static, this, f);
+InterpretedArgumentOopFinder finder(signature, has_receiver, this, f);
 finder.oops_do();
 }
 void frame::oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* reg_map) {
 assert(_cb != NULL, "sanity check");
 }
 class CompiledArgumentOopFinder: public SignatureInfo {
 protected:
 OopClosure*     _f;
-int             _offset;      // the current offset, incremented with each argument
+int             _offset;        // the current offset, incremented with each argument
-bool            _is_static;   // true if the callee is a static method
+bool            _has_receiver;  // true if the callee has a receiver
 frame           _fr;
 RegisterMap*    _reg_map;
 int             _arg_size;
 VMRegPair*      _regs;        // VMReg list of arguments
 oop *loc = _fr.oopmapreg_to_location(reg, _reg_map);
 _f->do_oop(loc);
 }
 public:
-CompiledArgumentOopFinder(symbolHandle signature, bool is_static, OopClosure* f, frame fr,  const RegisterMap* reg_map)
+CompiledArgumentOopFinder(symbolHandle signature, bool has_receiver, OopClosure* f, frame fr,  const RegisterMap* reg_map)
 : SignatureInfo(signature) {
 // initialize CompiledArgumentOopFinder
 _f         = f;
 _offset    = 0;
-_is_static = is_static;
+_has_receiver = has_receiver;
 _fr        = fr;
 _reg_map   = (RegisterMap*)reg_map;
-_arg_size  = ArgumentSizeComputer(signature).size() + (is_static ? 0 : 1);
+_arg_size  = ArgumentSizeComputer(signature).size() + (has_receiver ? 1 : 0);
 int arg_size;
-_regs = SharedRuntime::find_callee_arguments(signature(), is_static, &arg_size);
+_regs = SharedRuntime::find_callee_arguments(signature(), has_receiver, &arg_size);
 assert(arg_size == _arg_size, "wrong arg size");
 }
 void oops_do() {
-if (!_is_static) {
+if (_has_receiver) {
 handle_oop_offset();
 _offset++;
 }
 iterate_parameters();
 }
 };
-void frame::oops_compiled_arguments_do(symbolHandle signature, bool is_static, const RegisterMap* reg_map, OopClosure* f) {
+void frame::oops_compiled_arguments_do(symbolHandle signature, bool has_receiver, const RegisterMap* reg_map, OopClosure* f) {
 ResourceMark rm;
-CompiledArgumentOopFinder finder(signature, is_static, f, *this, reg_map);
+CompiledArgumentOopFinder finder(signature, has_receiver, f, *this, reg_map);
 finder.oops_do();
 }
 // Get receiver out of callers frame, i.e. find parameter 0 in callers

changeset 4567	7fc02fbe5c7a
parent 3908	24b55ad4c228
child 4573	6358f8c9ed3b