Minor field name cleanup in debugger.
Use the same naming convention for all fields of DebugInvokeReq structure.
Change-Id: Ieaf65eef592f96efa47975eef15334279ed4fc8a
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index bcee0764..0f32a96 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -2723,14 +2723,14 @@
}
}
- req->receiver_ = receiver;
- req->thread_ = thread;
- req->class_ = c;
- req->method_ = m;
- req->arg_count_ = arg_count;
- req->arg_values_ = arg_values;
- req->options_ = options;
- req->invoke_needed_ = true;
+ req->receiver = receiver;
+ req->thread = thread;
+ req->klass = c;
+ req->method = m;
+ req->arg_count = arg_count;
+ req->arg_values = arg_values;
+ req->options = options;
+ req->invoke_needed = true;
}
// The fact that we've released the thread list lock is a bit risky --- if the thread goes
@@ -2748,7 +2748,7 @@
VLOG(jdwp) << " Transferring control to event thread";
{
- MutexLock mu(self, req->lock_);
+ MutexLock mu(self, req->lock);
if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
VLOG(jdwp) << " Resuming all threads";
@@ -2759,8 +2759,8 @@
}
// Wait for the request to finish executing.
- while (req->invoke_needed_) {
- req->cond_.Wait(self);
+ while (req->invoke_needed) {
+ req->cond.Wait(self);
}
}
VLOG(jdwp) << " Control has returned from event thread";
@@ -2817,24 +2817,24 @@
}
// Translate the method through the vtable, unless the debugger wants to suppress it.
- mirror::ArtMethod* m = pReq->method_;
- if ((pReq->options_ & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver_ != NULL) {
- mirror::ArtMethod* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
+ mirror::ArtMethod* m = pReq->method;
+ if ((pReq->options & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver != NULL) {
+ mirror::ArtMethod* actual_method = pReq->klass->FindVirtualMethodForVirtualOrInterface(pReq->method);
if (actual_method != m) {
VLOG(jdwp) << "ExecuteMethod translated " << PrettyMethod(m) << " to " << PrettyMethod(actual_method);
m = actual_method;
}
}
VLOG(jdwp) << "ExecuteMethod " << PrettyMethod(m)
- << " receiver=" << pReq->receiver_
- << " arg_count=" << pReq->arg_count_;
+ << " receiver=" << pReq->receiver
+ << " arg_count=" << pReq->arg_count;
CHECK(m != NULL);
CHECK_EQ(sizeof(jvalue), sizeof(uint64_t));
MethodHelper mh(m);
ArgArray arg_array(mh.GetShorty(), mh.GetShortyLength());
- arg_array.BuildArgArray(soa, pReq->receiver_, reinterpret_cast<jvalue*>(pReq->arg_values_));
+ arg_array.BuildArgArray(soa, pReq->receiver, reinterpret_cast<jvalue*>(pReq->arg_values));
InvokeWithArgArray(soa, m, &arg_array, &pReq->result_value, mh.GetShorty()[0]);
mirror::Throwable* exception = soa.Self()->GetException(NULL);
diff --git a/runtime/debugger.h b/runtime/debugger.h
index 0a7cf5a..acbb2c6 100644
--- a/runtime/debugger.h
+++ b/runtime/debugger.h
@@ -48,28 +48,28 @@
*/
struct DebugInvokeReq {
DebugInvokeReq()
- : ready(false), invoke_needed_(false),
- receiver_(NULL), thread_(NULL), class_(NULL), method_(NULL),
- arg_count_(0), arg_values_(NULL), options_(0), error(JDWP::ERR_NONE),
+ : ready(false), invoke_needed(false),
+ receiver(NULL), thread(NULL), klass(NULL), method(NULL),
+ arg_count(0), arg_values(NULL), options(0), error(JDWP::ERR_NONE),
result_tag(JDWP::JT_VOID), exception(0),
- lock_("a DebugInvokeReq lock", kBreakpointInvokeLock),
- cond_("a DebugInvokeReq condition variable", lock_) {
+ lock("a DebugInvokeReq lock", kBreakpointInvokeLock),
+ cond("a DebugInvokeReq condition variable", lock) {
}
/* boolean; only set when we're in the tail end of an event handler */
bool ready;
/* boolean; set if the JDWP thread wants this thread to do work */
- bool invoke_needed_;
+ bool invoke_needed;
/* request */
- mirror::Object* receiver_; /* not used for ClassType.InvokeMethod */
- mirror::Object* thread_;
- mirror::Class* class_;
- mirror::ArtMethod* method_;
- uint32_t arg_count_;
- uint64_t* arg_values_; /* will be NULL if arg_count_ == 0 */
- uint32_t options_;
+ mirror::Object* receiver; /* not used for ClassType.InvokeMethod */
+ mirror::Object* thread;
+ mirror::Class* klass;
+ mirror::ArtMethod* method;
+ uint32_t arg_count;
+ uint64_t* arg_values; /* will be NULL if arg_count_ == 0 */
+ uint32_t options;
/* result */
JDWP::JdwpError error;
@@ -78,8 +78,8 @@
JDWP::ObjectId exception;
/* condition variable to wait on while the method executes */
- Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
- ConditionVariable cond_ GUARDED_BY(lock_);
+ Mutex lock DEFAULT_MUTEX_ACQUIRED_AFTER;
+ ConditionVariable cond GUARDED_BY(lock);
private:
DISALLOW_COPY_AND_ASSIGN(DebugInvokeReq);
diff --git a/runtime/jdwp/jdwp_event.cc b/runtime/jdwp/jdwp_event.cc
index 61bd1ed..b05b49d 100644
--- a/runtime/jdwp/jdwp_event.cc
+++ b/runtime/jdwp/jdwp_event.cc
@@ -521,7 +521,7 @@
* The JDWP thread has told us (and possibly all other threads) to
* resume. See if it has left anything in our DebugInvokeReq mailbox.
*/
- if (!pReq->invoke_needed_) {
+ if (!pReq->invoke_needed) {
/*LOGD("SuspendByPolicy: no invoke needed");*/
break;
}
@@ -535,12 +535,12 @@
pReq->error = ERR_NONE;
/* clear this before signaling */
- pReq->invoke_needed_ = false;
+ pReq->invoke_needed = false;
VLOG(jdwp) << "invoke complete, signaling and self-suspending";
Thread* self = Thread::Current();
- MutexLock mu(self, pReq->lock_);
- pReq->cond_.Signal(self);
+ MutexLock mu(self, pReq->lock);
+ pReq->cond.Signal(self);
}
}
@@ -570,7 +570,7 @@
*/
bool JdwpState::InvokeInProgress() {
DebugInvokeReq* pReq = Dbg::GetInvokeReq();
- return pReq->invoke_needed_;
+ return pReq->invoke_needed;
}
/*