// 敏感属性
window attr

// 存储
localStorage.(setItem|getItem), document.cookie

// 日期时间
Date.now, new Date().getTime, performance.now

// 编解码
JSON.(stringify|parse), atob, btoa

// 随机数
Math.random, crypto.getRandomValues

// 请求
XMLHttpRequest, fetch, WebSocket

// 动态代码
eval, Function

// WASM
WebAssembly.compile, WebAssembly.instantiate, WebAssembly.instantiateStreaming, WebAssembly.compileStreaming

// 直接替换方法 重写全局函数或对象方法
const originalSend = XMLHttpRequest.prototype.send;
XMLHttpRequest.prototype.send = function(body) {  // 这里也可以直接替换XMLHttpRequest.send
    console.log("发送请求:", body);
    return originalSend.apply(this, arguments);
};
// 替换属性访问
let _value = 100;
Object.defineProperty(obj, 'prop', {
    get() {
        console.log(`读取prop: ${_value}`);
        return _value;
    },
    set(newVal) {
        console.log(`设置prop: ${newVal}`);
        _value = newVal;
    }
});
// 替换为代理
const proxy = new Proxy(target, {
    get(target, prop) {
        console.log(`读取属性: ${prop}`);
        return Reflect.get(target, prop);
    },
    set(target, prop, value) {
        console.log(`设置属性: ${prop}=${value}`);
        return Reflect.set(target, prop, value);
    }
});

const callstack = new Error().stack.split("\n");

Math.random = function() {
  console.log("Hook Math.random: 返回固定值");
  // debugger; // 触发断点，便于跟踪调用栈
  return 0.5;
};

window.crypto.getRandomValues = function(array) {
  console.log("Hook crypto.getRandomValues: 填充固定值到数组");
  // debugger; // 触发断点

  for (let i = 0; i < array.length; i++) {
    array[i] = 0;
  }

  return array;
};

const _setTimeout = window.setTimeout;
window.setTimeout = function(cb, delay) {
  console.log(`[Hook] setTimeout: delay=${delay}ms`);
  if (delay < 100) delay = 1000; // 强制最小延迟
  return _setTimeout(() => {
    console.log("[Hook] 执行回调");
    cb(); // 可插入debugger
  }, delay);
};

window.setInterval = function(cb, interval) {
  console.log(`[Hook] setInterval: interval=${interval}ms`);
  const proxyCB = () => {
    console.log(`[Hook] 周期执行计数`);
    cb();
  };
  return _setInterval(proxyCB, interval);
};

diff --git a/src/interpreter/bytecode-generator.cc b/src/interpreter/bytecode-generator.cc
index 0464ba548d..d1b65fb6b4 100644
--- a/src/interpreter/bytecode-generator.cc
+++ b/src/interpreter/bytecode-generator.cc
@@ -4489,6 +4537,18 @@ void BytecodeGenerator::VisitPropertyLoad(Register obj, Property* property) {
     case NON_PROPERTY:
       UNREACHABLE();
     case NAMED_PROPERTY: {     // 对于obj.prop的读访问。 case KEYED_PROPERTY是obj['prop']
+      // VisibleV8: generate code to trace named property loads
+      {
+        RegisterList trace_args = register_allocator()->NewRegisterList(3);        // 分配3个寄存器存储参数
+        builder()->    // builder是字节码生成器的构建器，它能正确选择最合适的字节码
+          LoadLiteral(Smi::FromInt(property->position())).  // 将位置放到累加器里
+          StoreAccumulatorInRegister(trace_args[0]).  // 将累加器值存到参数1
+          MoveRegister(obj, trace_args[1]).    // 将对象存到参数2
+          LoadLiteral(property->key()->AsLiteral()->AsRawPropertyName()).      // 获取属性名到累加器
+          StoreAccumulatorInRegister(trace_args[2]).   // 将属性名存到参数3
+          CallRuntime(Runtime::kTracePropertyLoad, trace_args); //args: (call-site, this, key) 调用插入的log函数
+      }
+

diff --git a/src/builtins/reflect.tq b/src/builtins/reflect.tq
index 95d83b5ead..0292b35287 100644
--- a/src/builtins/reflect.tq
+++ b/src/builtins/reflect.tq
@@ -58,6 +58,9 @@ namespace reflect {
   extern transitioning builtin GetPropertyWithReceiver(
       implicit context: Context)(JSAny, Name, JSAny, Smi): JSAny;

+  // VisibleV8: defining external trace-property-load runtime function
+  extern transitioning runtime TracePropertyLoad(implicit context: Context)(Smi, JSAny, JSAny);
+
   // ES6 section 26.1.6 Reflect.get
   transitioning javascript builtin
   ReflectGet(js-implicit context: NativeContext)(...arguments): JSAny {
@@ -68,6 +71,10 @@ namespace reflect {
     const propertyKey: JSAny = length > 1 ? arguments[1] : Undefined;
     const name: AnyName = ToName(propertyKey);
     const receiver: JSAny = length > 2 ? arguments[2] : objectJSReceiver;
+
+    // VisibleV8: call-out to property-load tracer runtime function
+    TracePropertyLoad(-1, object, propertyKey);
+
     return GetPropertyWithReceiver(
         objectJSReceiver, name, receiver, SmiConstant(kReturnUndefined));
   }

~0x2e54001cc000     
@?
!?
$5:"https\://g.alicdn.com/??mtb/lib-promise/3.1.3/polyfillB.js,mtb/lib-windvane/3.0.7/windvane.js":!function a(b,c,d){function e(g,h){i....
c-1:%Save:{158894,Window}:"Object":%safe
g212098:{249011,Window}:"navigator"
s75:{158894,Window}:"enableWwSsoPluginLogin":#T

+// Predicate to see if an object (for property load/store) is worth logging
+static bool visv8_should_log_object(Object obj) {
+  if (obj.IsPrimitive()) {
+    // Never log accesses on primitive values
+    return false;
+  }
+
+  HeapObject hobj = HeapObject::cast(obj);
+  auto itype = hobj.map().instance_type();
+ // JS_GLOBAL_OBJECT_TYPE 是全局对象，即window下的，如navigator
+ // JS_GLOBAL_PROXY_TYPE 是全局对象的代理
+ // JS_API_OBJECT_TYPE 是V8扩展API创建的
+ // JS_SPECIAL_API_OBJECT_TYPE 是特需的
+  return ((itype == JS_GLOBAL_OBJECT_TYPE) || (itype == JS_GLOBAL_PROXY_TYPE) ||
+          (itype == JS_SPECIAL_API_OBJECT_TYPE) ||
+          (itype == JS_API_OBJECT_TYPE));
+}
+

// variable write
function W(iid, name, val, lhs, flags) {
    var bFlags = decodeBitPattern(flags, 3); // 解码标志位 [isGlobal, isScriptLocal, isDeclaration]
    var aret;
    if (sandbox.analysis && sandbox.analysis.write) {   // 如分析插件定义了write就调用它
        aret = sandbox.analysis.write(iid, name, val, lhs, bFlags[0], bFlags[1]);
        if (aret) { // 如果write有返回值，就用新的返回值覆盖原始值
            val = aret.result;
        }
    }
    if (!bFlags[2]) {   // 执行真正的写操作
        return (lastComputedValue = val);
    } else {
        lastComputedValue = undefined;
        return val;
    }
}

├── docs  # 各种文档 有可能并不是最新的
├── scripts
│   ├── proxy.py    # mitmproxy实时插桩分析
│   ├── sj.py       # 跨平台node操作封装
├── src
│   ├── java
│   ├── js
│   │   ├── commands
│   │   │   ├── curl.js
│   │   │   ├── direct.js   # 对于已经插桩的代码，直接运行分析插件
│   │   │   ├── esnstrument_cli.js  # 对单个文件插桩
│   │   │   ├── instrument.js   # 对目录/多个文件插桩
│   │   │   ├── jalangi.js  # 运行插桩+分析
│   │   ├── Config.js               # 配置对哪些部分插桩，这是JS，可以做精细化控制
│   │   ├── instrument
│   │   │   ├── astUtil.js
│   │   │   ├── esnstrument.js  # 插桩的核心逻辑
│   │   │   └── instUtil.js
│   │   ├── runtime
│   │   │   ├── analysis.js         # 分析代码，它会调用我们编写的分析插件
│   │   │   ├── analysisCallbackTemplate.js # 模板代码，可以基于它写分析插件
│   │   │   ├── iidToLocation.js    # id转源码位置
│   │   │   └── SMemory.js  # 影子内存
│   │   ├── sample_analyses
│   │   │   ├── ChainedAnalyses.js              # 链式分析，来支持同时使用多个分析插件 [PS：感觉怪怪的，像是临时打了个不定来支持，似乎设计时就该有这种能力?]
│   │   │   ├── coverage                        # 记录代码覆盖率的，可用于追踪分支/脚本执行情况
│   │   │   │   ├── AddCoverage.js
│   │   │   │   ├── mocha_prefix.js
│   │   │   │   ├── ProcessCoverage.js
│   │   │   │   ├── qunit_prefix.js
│   │   │   │   ├── SpecialCoverage.js
│   │   │   │   └── tests
│   │   │   │       ├── FeaturesMain.js
│   │   │   │       ├── FeaturesTest.js
│   │   │   │       └── SetTest.js
│   │   │   ├── datatraces                      # 这里的样例是用于做trace的，比如属性读些访问的，很有用！
│   │   │   │   ├── LogData.js
│   │   │   │   └── TraceWriter.js
│   │   │   ├── pldi16
│   │   │   │   ├── BackTrackLoop.js
│   │   │   │   ├── BranchCoverage.js
│   │   │   │   ├── ChangeSematicsOfMult.js
│   │   │   │   ├── CheckUndefinedConcatenatedToString.js
│   │   │   │   ├── CountObjectsPerAllocationSite.js
│   │   │   │   ├── LogLoadStore.js
│   │   │   │   ├── LogLoadStoreAlloc.js
│   │   │   │   ├── SkipFunction.js
│   │   │   │   └── TraceAll.js     # 追踪所有插桩点，打log
│   │   ├── template.js
│   │   └── utils
│   │       ├── api.js  # 便node等编程使用，去插桩和分析
│   └── python
│       └── datatraces.py
└── tests