GitLab will be upgraded to the 12.10.14-ce.0 on 28 Sept 2020 at 2.00pm (AEDT) to 2.30pm (AEDT). During the update, GitLab and Mattermost services will not be available. If you have any concerns with this, please talk to us at N110 (b) CSIT building.

Commit 0b7c8424 authored by qinsoon's avatar qinsoon

[wip] more clear debug info

parent 4f5b2e41
...@@ -224,9 +224,20 @@ pub struct Instruction { ...@@ -224,9 +224,20 @@ pub struct Instruction {
pub v: Instruction_ pub v: Instruction_
} }
impl Instruction {
fn debug_str(&self, ops: &Vec<P<TreeNode>>) -> String {
self.v.debug_str(ops)
}
}
impl fmt::Debug for Instruction { impl fmt::Debug for Instruction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?} (value: {:?}, ops: {:?})", self.v, self.value, self.ops.borrow()) let ops = &self.ops.borrow();
if self.value.is_some() {
write!(f, "{:?} = {}", self.value.as_ref().unwrap(), self.v.debug_str(ops))
} else {
write!(f, "{}", self.v.debug_str(ops))
}
} }
} }
...@@ -401,6 +412,109 @@ macro_rules! select { ...@@ -401,6 +412,109 @@ macro_rules! select {
} }
} }
impl Instruction_ {
fn debug_str(&self, ops: &Vec<P<TreeNode>>) -> String {
match self {
&Instruction_::BinOp(op, op1, op2) => fmt::format(format_args!("{:?} {:?} {:?}", op, ops[op1], ops[op2])),
&Instruction_::CmpOp(op, op1, op2) => fmt::format(format_args!("{:?} {:?} {:?}", op, ops[op1], ops[op2])),
&Instruction_::ExprCall{ref data, is_abort} => {
let abort = select!(is_abort, "ABORT_ON_EXN", "RETHROW");
fmt::format(format_args!("CALL {} {}", data.debug_str(ops), abort))
},
&Instruction_::Load{is_ptr, mem_loc, order} => {
let ptr = select!(is_ptr, "PTR", "");
fmt::format(format_args!("LOAD {} {:?} {:?}", ptr, order, ops[mem_loc]))
},
&Instruction_::Store{value, is_ptr, mem_loc, order} => {
let ptr = select!(is_ptr, "PTR", "");
fmt::format(format_args!("STORE {} {:?} {:?} {:?}", ptr, order, ops[mem_loc], ops[value]))
},
&Instruction_::CmpXchg{is_ptr, is_weak, success_order, fail_order,
mem_loc, expected_value, desired_value} => {
let ptr = select!(is_ptr, "PTR", "");
let weak = select!(is_weak, "WEAK", "");
fmt::format(format_args!("CMPXCHG {} {} {:?} {:?} {:?} {:?} {:?}",
ptr, weak, success_order, fail_order, ops[mem_loc], ops[expected_value], ops[desired_value]))
},
&Instruction_::AtomicRMW{is_ptr, order, op, mem_loc, value} => {
let ptr = select!(is_ptr, "PTR", "");
fmt::format(format_args!("ATOMICRMW {} {:?} {:?} {:?} {:?}", ptr, order, op, ops[mem_loc], ops[value]))
},
&Instruction_::New(ref ty) => fmt::format(format_args!("NEW {:?}", ty)),
&Instruction_::AllocA(ref ty) => fmt::format(format_args!("ALLOCA {:?}", ty)),
&Instruction_::NewHybrid(ref ty, len) => fmt::format(format_args!("NEWHYBRID {:?} {:?}", ty, ops[len])),
&Instruction_::AllocAHybrid(ref ty, len) => fmt::format(format_args!("ALLOCAHYBRID {:?} {:?}", ty, ops[len])),
&Instruction_::NewStack(func) => fmt::format(format_args!("NEWSTACK {:?}", ops[func])),
&Instruction_::NewThread(stack, ref args) => fmt::format(format_args!("NEWTHREAD {:?} PASS_VALUES {}", ops[stack], op_vector_str(args, ops))),
&Instruction_::NewThreadExn(stack, exn) => fmt::format(format_args!("NEWTHREAD {:?} THROW_EXC {:?}", ops[stack], ops[exn])),
&Instruction_::NewFrameCursor(stack) => fmt::format(format_args!("NEWFRAMECURSOR {:?}", ops[stack])),
&Instruction_::GetIRef(reference) => fmt::format(format_args!("GETIREF {:?}", ops[reference])),
&Instruction_::GetFieldIRef{is_ptr, base, index} => {
let ptr = select!(is_ptr, "PTR", "");
fmt::format(format_args!("GETFIELDIREF {} {:?} {:?}", ptr, ops[base], ops[index]))
},
&Instruction_::GetElementIRef{is_ptr, base, index} => {
let ptr = select!(is_ptr, "PTR", "");
fmt::format(format_args!("GETELEMENTIREF {} {:?} {:?}", ptr, ops[base], ops[index]))
},
&Instruction_::ShiftIRef{is_ptr, base, offset} => {
let ptr = select!(is_ptr, "PTR", "");
fmt::format(format_args!("SHIFTIREF {} {:?} {:?}", ptr, ops[base], ops[offset]))
},
&Instruction_::GetVarPartIRef{is_ptr, base} => {
let ptr = select!(is_ptr, "PTR", "");
fmt::format(format_args!("GETVARPARTIREF {} {:?}", ptr, ops[base]))
},
&Instruction_::Fence(order) => {
fmt::format(format_args!("FENCE {:?}", order))
},
&Instruction_::Return(ref vals) => fmt::format(format_args!("RET {}", op_vector_str(vals, ops))),
&Instruction_::ThreadExit => "THREADEXIT".to_string(),
&Instruction_::Throw(ref vals) => fmt::format(format_args!("THROW {}", op_vector_str(vals, ops))),
&Instruction_::TailCall(ref call) => fmt::format(format_args!("TAILCALL {}", call.debug_str(ops))),
&Instruction_::Branch1(ref dest) => fmt::format(format_args!("BRANCH {:?}", dest.debug_str(ops))),
&Instruction_::Branch2{cond, ref true_dest, ref false_dest} => {
fmt::format(format_args!("BRANCH2 {:?} {} {}", ops[cond], true_dest.debug_str(ops), false_dest.debug_str(ops)))
},
&Instruction_::Watchpoint{id, ref disable_dest, ref resume} => {
match id {
Some(id) => {
fmt::format(format_args!("WATCHPOINT {:?} {} {}", id, disable_dest.as_ref().unwrap().debug_str(ops), resume.debug_str(ops)))
},
None => {
fmt::format(format_args!("TRAP {}", resume.debug_str(ops)))
}
}
},
&Instruction_::WPBranch{wp, ref disable_dest, ref enable_dest} => {
fmt::format(format_args!("WPBRANCH {:?} {} {}", wp, disable_dest.debug_str(ops), enable_dest.debug_str(ops)))
},
&Instruction_::Call{ref data, ref resume} => fmt::format(format_args!("CALL {} {}", data.debug_str(ops), resume.debug_str(ops))),
&Instruction_::SwapStack{stack, is_exception, ref args, ref resume} => {
fmt::format(format_args!("SWAPSTACK {:?} {:?} {} {}", ops[stack], is_exception, op_vector_str(args, ops), resume.debug_str(ops)))
},
&Instruction_::Switch{cond, ref default, ref branches} => {
let mut ret = fmt::format(format_args!("SWITCH {:?} {:?} {{", cond, default.debug_str(ops)));
for i in 0..branches.len() {
let (op, ref dest) = branches[i];
ret.push_str(fmt::format(format_args!("{:?} {}", ops[op], dest.debug_str(ops))).as_str());
if i != branches.len() - 1 {
ret.push_str(", ");
}
}
ret.push_str("}}");
ret
},
&Instruction_::ExnInstruction{ref inner, ref resume} => {
fmt::format(format_args!("{:?} {:?}", inner.debug_str(ops), resume.debug_str(ops)))
}
}
}
}
impl fmt::Debug for Instruction_ { impl fmt::Debug for Instruction_ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
...@@ -523,6 +637,12 @@ pub struct CallData { ...@@ -523,6 +637,12 @@ pub struct CallData {
pub convention: CallConvention pub convention: CallConvention
} }
impl CallData {
fn debug_str(&self, ops: &Vec<P<TreeNode>>) -> String {
fmt::format(format_args!("{:?} {:?} ({})", self.convention, ops[self.func], op_vector_str(&self.args, ops)))
}
}
impl fmt::Debug for CallData { impl fmt::Debug for CallData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?} {:?} ({:?})", self.convention, self.func, self.args) write!(f, "{:?} {:?} ({:?})", self.convention, self.func, self.args)
...@@ -535,6 +655,12 @@ pub struct ResumptionData { ...@@ -535,6 +655,12 @@ pub struct ResumptionData {
pub exn_dest: Destination pub exn_dest: Destination
} }
impl ResumptionData {
fn debug_str(&self, ops: &Vec<P<TreeNode>>) -> String {
fmt::format(format_args!("normal: {:?}, exception: {:?}", self.normal_dest.debug_str(ops), self.exn_dest.debug_str(ops)))
}
}
impl fmt::Debug for ResumptionData { impl fmt::Debug for ResumptionData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "normal: {:?}, exception: {:?}", self.normal_dest, self.exn_dest) write!(f, "normal: {:?}, exception: {:?}", self.normal_dest, self.exn_dest)
...@@ -547,6 +673,23 @@ pub struct Destination { ...@@ -547,6 +673,23 @@ pub struct Destination {
pub args: Vec<DestArg> pub args: Vec<DestArg>
} }
impl Destination {
fn debug_str(&self, ops: &Vec<P<TreeNode>>) -> String {
let mut ret = fmt::format(format_args!("{}", self.target));
ret.push('[');
for i in 0..self.args.len() {
let ref arg = self.args[i];
ret.push_str(arg.debug_str(ops).as_str());
if i != self.args.len() - 1 {
ret.push_str(", ");
}
}
ret.push(']');
ret
}
}
impl fmt::Debug for Destination { impl fmt::Debug for Destination {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}{:?}", self.target, self.args) write!(f, "{}{:?}", self.target, self.args)
...@@ -559,6 +702,15 @@ pub enum DestArg { ...@@ -559,6 +702,15 @@ pub enum DestArg {
Freshbound(usize) Freshbound(usize)
} }
impl DestArg {
fn debug_str(&self, ops: &Vec<P<TreeNode>>) -> String {
match self {
&DestArg::Normal(index) => fmt::format(format_args!("{:?}", ops[index])),
&DestArg::Freshbound(n) => fmt::format(format_args!("${:?}", n))
}
}
}
impl fmt::Debug for DestArg { impl fmt::Debug for DestArg {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
...@@ -566,4 +718,16 @@ impl fmt::Debug for DestArg { ...@@ -566,4 +718,16 @@ impl fmt::Debug for DestArg {
&DestArg::Freshbound(n) => write!(f, "${}", n) &DestArg::Freshbound(n) => write!(f, "${}", n)
} }
} }
}
fn op_vector_str(vec: &Vec<OpIndex>, ops: &Vec<P<TreeNode>>) -> String {
let mut ret = String::new();
for i in 0..vec.len() {
let index = vec[i];
ret.push_str(fmt::format(format_args!("{:?}", ops[index])).as_str());
if i != vec.len() - 1 {
ret.push_str(", ");
}
}
ret
} }
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment