358 lines
11 KiB
Plaintext
358 lines
11 KiB
Plaintext
// slots.ce — slot data flow / use-def chains
|
|
//
|
|
// Usage:
|
|
// cell slots --fn <N|name> <file> Slot summary for function
|
|
// cell slots --slot <N> --fn <N|name> <file> Trace slot N in function
|
|
// cell slots <file> Slot summary for all functions
|
|
|
|
var shop = use("internal/shop")
|
|
|
|
var pad_right = function(s, w) {
|
|
var r = s
|
|
while (length(r) < w) {
|
|
r = r + " "
|
|
}
|
|
return r
|
|
}
|
|
|
|
var fmt_val = function(v) {
|
|
if (is_null(v)) return "null"
|
|
if (is_number(v)) return text(v)
|
|
if (is_text(v)) return `"${v}"`
|
|
if (is_object(v)) return text(v)
|
|
if (is_logical(v)) return v ? "true" : "false"
|
|
return text(v)
|
|
}
|
|
|
|
// Classify instruction operands as DEF or USE
|
|
// Returns {defs: [operand_positions], uses: [operand_positions]}
|
|
// Positions are 1-based indices into the instruction array
|
|
var classify_operands = function(op) {
|
|
// Binary ops: DEF=[1], USE=[2,3]
|
|
if (op == "add" || op == "subtract" || op == "multiply" || op == "divide" ||
|
|
op == "modulo" || op == "pow" || op == "remainder" ||
|
|
op == "add_int" || op == "sub_int" || op == "mul_int" || op == "div_int" ||
|
|
op == "mod_int" || op == "pow_int" || op == "rem_int" ||
|
|
op == "add_float" || op == "sub_float" || op == "mul_float" || op == "div_float" ||
|
|
op == "mod_float" || op == "pow_float" ||
|
|
op == "eq" || op == "ne" || op == "lt" || op == "gt" || op == "le" || op == "ge" ||
|
|
op == "eq_int" || op == "ne_int" || op == "lt_int" || op == "gt_int" ||
|
|
op == "le_int" || op == "ge_int" ||
|
|
op == "eq_float" || op == "ne_float" || op == "lt_float" || op == "gt_float" ||
|
|
op == "le_float" || op == "ge_float" ||
|
|
op == "eq_text" || op == "ne_text" || op == "lt_text" || op == "gt_text" ||
|
|
op == "le_text" || op == "ge_text" ||
|
|
op == "eq_bool" || op == "ne_bool" ||
|
|
op == "concat" ||
|
|
op == "bitand" || op == "bitor" || op == "bitxor" ||
|
|
op == "shl" || op == "shr" || op == "ushr" ||
|
|
op == "and" || op == "or" ||
|
|
op == "is_identical") {
|
|
return {defs: [1], uses: [2, 3]}
|
|
}
|
|
|
|
// Unary ops: DEF=[1], USE=[2]
|
|
if (op == "not" || op == "negate" || op == "neg_int" || op == "neg_float" ||
|
|
op == "bitnot" || op == "typeof" || op == "length" ||
|
|
op == "is_int" || op == "is_num" || op == "is_text" || op == "is_bool" ||
|
|
op == "is_null" || op == "is_array" || op == "is_func" || op == "is_record" ||
|
|
op == "is_stone" || op == "is_integer") {
|
|
return {defs: [1], uses: [2]}
|
|
}
|
|
|
|
// Constants: DEF=[1], USE=[]
|
|
if (op == "int" || op == "true" || op == "false" || op == "null" || op == "access") {
|
|
return {defs: [1], uses: []}
|
|
}
|
|
|
|
if (op == "move") return {defs: [1], uses: [2]}
|
|
if (op == "function") return {defs: [1], uses: []}
|
|
if (op == "array") return {defs: [1], uses: []}
|
|
if (op == "record") return {defs: [1], uses: []}
|
|
if (op == "frame") return {defs: [1], uses: [2]}
|
|
if (op == "setarg") return {defs: [], uses: [1, 3]}
|
|
if (op == "invoke") return {defs: [2], uses: [1]}
|
|
if (op == "tail_invoke" || op == "goinvoke") return {defs: [], uses: [1]}
|
|
if (op == "load_field") return {defs: [1], uses: [2]}
|
|
if (op == "store_field") return {defs: [], uses: [1, 3]}
|
|
if (op == "load_index" || op == "load_dynamic") return {defs: [1], uses: [2, 3]}
|
|
if (op == "store_index" || op == "store_dynamic") return {defs: [], uses: [1, 2, 3]}
|
|
if (op == "push") return {defs: [], uses: [1, 2]}
|
|
if (op == "pop") return {defs: [1], uses: [2]}
|
|
if (op == "jump_true" || op == "jump_false" || op == "jump_null" || op == "jump_not_null") return {defs: [], uses: [1]}
|
|
if (op == "jump") return {defs: [], uses: []}
|
|
if (op == "return") return {defs: [], uses: [1]}
|
|
if (op == "disrupt") return {defs: [], uses: []}
|
|
if (op == "get") return {defs: [1], uses: []}
|
|
if (op == "set_var") return {defs: [], uses: [1]}
|
|
|
|
return {defs: [], uses: []}
|
|
}
|
|
|
|
var run = function() {
|
|
var filename = null
|
|
var fn_filter = null
|
|
var slot_filter = null
|
|
var i = 0
|
|
var compiled = null
|
|
var type_info = {}
|
|
var sl_log = null
|
|
var td = null
|
|
var main_name = null
|
|
var fi = 0
|
|
var func = null
|
|
var fname = null
|
|
|
|
while (i < length(args)) {
|
|
if (args[i] == '--fn') {
|
|
i = i + 1
|
|
fn_filter = args[i]
|
|
} else if (args[i] == '--slot') {
|
|
i = i + 1
|
|
slot_filter = number(args[i])
|
|
} else if (args[i] == '--help' || args[i] == '-h') {
|
|
log.console("Usage: cell slots [--fn <N|name>] [--slot <N>] <file>")
|
|
log.console("")
|
|
log.console(" --fn <N|name> Filter to function by index or name")
|
|
log.console(" --slot <N> Trace a specific slot")
|
|
return null
|
|
} else if (!starts_with(args[i], '-')) {
|
|
filename = args[i]
|
|
}
|
|
i = i + 1
|
|
}
|
|
|
|
if (!filename) {
|
|
log.console("Usage: cell slots [--fn <N|name>] [--slot <N>] <file>")
|
|
return null
|
|
}
|
|
|
|
compiled = shop.mcode_file(filename)
|
|
|
|
// Try to get type info from streamline
|
|
var get_type_info = function() {
|
|
var mcode_copy = shop.mcode_file(filename)
|
|
var streamline = use("streamline")
|
|
var ti = 0
|
|
sl_log = {
|
|
passes: [],
|
|
events: null,
|
|
type_deltas: []
|
|
}
|
|
streamline(mcode_copy, sl_log)
|
|
if (sl_log.type_deltas != null) {
|
|
ti = 0
|
|
while (ti < length(sl_log.type_deltas)) {
|
|
td = sl_log.type_deltas[ti]
|
|
if (td.fn != null) {
|
|
type_info[td.fn] = td.slot_types
|
|
}
|
|
ti = ti + 1
|
|
}
|
|
}
|
|
return null
|
|
} disruption {
|
|
// Type info is optional
|
|
}
|
|
get_type_info()
|
|
|
|
var fn_matches = function(index, name) {
|
|
var match = null
|
|
if (fn_filter == null) return true
|
|
if (index >= 0 && fn_filter == text(index)) return true
|
|
if (name != null) {
|
|
match = search(name, fn_filter)
|
|
if (match != null && match >= 0) return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var analyze_function = function(func, name, index) {
|
|
var nr_args = func.nr_args != null ? func.nr_args : 0
|
|
var nr_slots = func.nr_slots != null ? func.nr_slots : 0
|
|
var instrs = func.instructions
|
|
var defs = {}
|
|
var uses = {}
|
|
var first_def = {}
|
|
var first_def_op = {}
|
|
var events = []
|
|
var pc = 0
|
|
var ii = 0
|
|
var instr = null
|
|
var op = null
|
|
var n = 0
|
|
var cls = null
|
|
var di = 0
|
|
var ui = 0
|
|
var slot_num = null
|
|
var operand_val = null
|
|
var parts = null
|
|
var j = 0
|
|
var operands = null
|
|
var slot_types = null
|
|
var type_key = null
|
|
var ei = 0
|
|
var evt = null
|
|
var found = false
|
|
var line_str = null
|
|
var si = 0
|
|
var slot_key = null
|
|
var d_count = 0
|
|
var u_count = 0
|
|
var t = null
|
|
var first = null
|
|
var dead_marker = null
|
|
|
|
if (instrs == null) instrs = []
|
|
|
|
// Walk instructions, build def/use chains
|
|
ii = 0
|
|
while (ii < length(instrs)) {
|
|
instr = instrs[ii]
|
|
if (is_text(instr)) {
|
|
ii = ii + 1
|
|
continue
|
|
}
|
|
if (!is_array(instr)) {
|
|
ii = ii + 1
|
|
continue
|
|
}
|
|
|
|
op = instr[0]
|
|
n = length(instr)
|
|
cls = classify_operands(op)
|
|
|
|
di = 0
|
|
while (di < length(cls.defs)) {
|
|
operand_val = instr[cls.defs[di]]
|
|
if (is_number(operand_val)) {
|
|
slot_num = text(operand_val)
|
|
if (!defs[slot_num]) defs[slot_num] = 0
|
|
defs[slot_num] = defs[slot_num] + 1
|
|
if (first_def[slot_num] == null) {
|
|
first_def[slot_num] = pc
|
|
first_def_op[slot_num] = op
|
|
}
|
|
push(events, {kind: "DEF", slot: operand_val, pc: pc, instr: instr})
|
|
}
|
|
di = di + 1
|
|
}
|
|
|
|
ui = 0
|
|
while (ui < length(cls.uses)) {
|
|
operand_val = instr[cls.uses[ui]]
|
|
if (is_number(operand_val)) {
|
|
slot_num = text(operand_val)
|
|
if (!uses[slot_num]) uses[slot_num] = 0
|
|
uses[slot_num] = uses[slot_num] + 1
|
|
push(events, {kind: "USE", slot: operand_val, pc: pc, instr: instr})
|
|
}
|
|
ui = ui + 1
|
|
}
|
|
|
|
pc = pc + 1
|
|
ii = ii + 1
|
|
}
|
|
|
|
// Get type info for this function
|
|
type_key = func.name != null ? func.name : name
|
|
if (type_info[type_key]) {
|
|
slot_types = type_info[type_key]
|
|
}
|
|
|
|
// --slot mode: show trace
|
|
if (slot_filter != null) {
|
|
log.compile(`\n=== slot ${text(slot_filter)} in ${name} ===`)
|
|
ei = 0
|
|
found = false
|
|
while (ei < length(events)) {
|
|
evt = events[ei]
|
|
if (evt.slot == slot_filter) {
|
|
found = true
|
|
n = length(evt.instr)
|
|
parts = []
|
|
j = 1
|
|
while (j < n - 2) {
|
|
push(parts, fmt_val(evt.instr[j]))
|
|
j = j + 1
|
|
}
|
|
operands = text(parts, ", ")
|
|
line_str = evt.instr[n - 2] != null ? `:${text(evt.instr[n - 2])}` : ""
|
|
log.compile(` ${pad_right(evt.kind, 5)}pc ${pad_right(text(evt.pc) + ":", 6)} ${pad_right(evt.instr[0], 15)}${pad_right(operands, 30)}${line_str}`)
|
|
}
|
|
ei = ei + 1
|
|
}
|
|
if (!found) {
|
|
log.compile(" (no activity)")
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Summary mode
|
|
log.compile(`\n=== ${name} (args=${text(nr_args)}, slots=${text(nr_slots)}) ===`)
|
|
log.compile(` ${pad_right("slot", 8)}${pad_right("defs", 8)}${pad_right("uses", 8)}${pad_right("type", 12)}first-def`)
|
|
|
|
si = 0
|
|
while (si < nr_slots) {
|
|
slot_key = text(si)
|
|
d_count = defs[slot_key] != null ? defs[slot_key] : 0
|
|
u_count = uses[slot_key] != null ? uses[slot_key] : 0
|
|
|
|
// Skip slots with no activity unless they're args or have type info
|
|
if (d_count == 0 && u_count == 0 && si >= nr_args + 1) {
|
|
si = si + 1
|
|
continue
|
|
}
|
|
|
|
t = "-"
|
|
if (slot_types != null && slot_types[slot_key] != null) {
|
|
t = slot_types[slot_key]
|
|
}
|
|
|
|
first = ""
|
|
if (si == 0) {
|
|
first = "(this)"
|
|
} else if (si > 0 && si <= nr_args) {
|
|
first = `(arg ${text(si - 1)})`
|
|
} else if (first_def[slot_key] != null) {
|
|
first = `pc ${text(first_def[slot_key])}: ${first_def_op[slot_key]}`
|
|
}
|
|
|
|
dead_marker = ""
|
|
if (d_count > 0 && u_count == 0 && si > nr_args) {
|
|
dead_marker = " <- dead"
|
|
}
|
|
|
|
log.compile(` ${pad_right("s" + slot_key, 8)}${pad_right(text(d_count), 8)}${pad_right(text(u_count), 8)}${pad_right(t, 12)}${first}${dead_marker}`)
|
|
si = si + 1
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Process functions
|
|
main_name = compiled.name != null ? compiled.name : "<main>"
|
|
|
|
if (compiled.main != null) {
|
|
if (fn_matches(-1, main_name)) {
|
|
analyze_function(compiled.main, main_name, -1)
|
|
}
|
|
}
|
|
|
|
if (compiled.functions != null) {
|
|
fi = 0
|
|
while (fi < length(compiled.functions)) {
|
|
func = compiled.functions[fi]
|
|
fname = func.name != null ? func.name : "<anonymous>"
|
|
if (fn_matches(fi, fname)) {
|
|
analyze_function(func, `[${text(fi)}] ${fname}`, fi)
|
|
}
|
|
fi = fi + 1
|
|
}
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
run()
|
|
$stop()
|