v8 147.3.0

Rust bindings to V8
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199

# Copyright 2025 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import pathlib
import typing

from graph import all_headers
from graph import calculate_rdeps
from graph import Header
from graph import IncludeDir
from graph import Target
from platforms import Os

if typing.TYPE_CHECKING:
  # To fix circular dependency.
  from compiler import Compiler

IGNORED_MODULES = [
    # This is a builtin module with feature requirements.
    'opencl_c',
    # This is a mac module with feature requirements that should be disabled.
    '_stddef',
]

# When any of the following directory names are in the path, it's treated as a
# sysroot directory.
SYSROOT_DIRS = {
    'android_toolchain',
    'debian_bullseye_amd64-sysroot',
    'debian_bullseye_arm64-sysroot',
    'debian_bullseye_armhf-sysroot',
    'debian_bullseye_i386-sysroot',
    'fuchsia-sdk',
    'MacOSX.platform',
    'win_toolchain',
}

# It doesn't matter if these don't work on all platforms.
# It'll just print a warning saying it failed to compile.
# This contains a list of files that aren't depended on by libc++, but we still
# want to precompile.
SYSROOT_PRECOMPILED_HEADERS = [
    'fcntl.h',
    'getopt.h',
    'linux/types.h',
    'sys/ioctl.h',
    'syscall.h',
]


def fix_graph(graph: dict[str, Header],
              compiler: 'Compiler') -> dict[pathlib.Path, str]:
  """Applies manual augmentation of the header graph."""

  def force_textual(key: str):
    if key in graph:
      graph[key].textual = True

  def add_dep(frm, to, check=True):
    if check:
      assert to not in frm.deps
    if to not in frm.deps:
      frm.deps.append(to)

  def skip_module(name):
    found = False
    for hdr in graph.values():
      while True:
        if hdr.root_module == name:
          hdr.textual = True
          found = True
        if hdr.next is None:
          break
        hdr = hdr.next
    assert found

  # We made the assumption that the deps of something we couldn't compile is
  # the intersection of the deps of all users of it.
  # This does not hold true for stddef.h because of __need_size_t
  add_dep(graph['stddef.h'].next, graph['__stddef_size_t.h'], check=False)

  if compiler.os in [Os.Android, Os.Win, Os.Fuchsia]:
    # include_next behaves differently in module builds and non-module builds.
    # Because of this, module builds include libcxx's wchar.h instead of
    # the sysroot's wchar.h
    add_dep(graph['__mbstate_t.h'], graph['wchar.h'])
    # This makes the libcxx/wchar.h included by mbstate_t.h act more like
    # sysroot/wchar.h by preventing it from defining functions.
    graph['__mbstate_t.h'].kwargs['defines'].append(
        '_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS')
  elif compiler.os.is_apple:
    # This is shadowed by the builtin iso646, so we don't need to build it.
    graph['iso646.h'].next.textual = True

  rdeps = calculate_rdeps(all_headers(graph))

  sysroot = graph['assert.h'].abs.parent
  for header in all_headers(graph):
    header.direct_deps = header.calculate_direct_deps(graph, sysroot=sysroot)

  if compiler.os.is_apple:
    # See https://github.com/llvm/llvm-project/issues/154675
    # Darwin defines the symbol "echo" in curses.h
    # Although curses.h is not included, the symbol is part of the module and
    # thus we get an error when attempting to use the symbol "echo" after
    # including *any* part of the module Darwin.
    skip_module("Darwin")
    # This module isn't intended to be used - it's intended to catch
    # misconfigured sysroots.
    skip_module("_c_standard_library_obsolete")
  else:
    for header in all_headers(graph):
      if header.include_dir != IncludeDir.Sysroot:
        continue

      parts = set(pathlib.Path(header.rel).parts)
      # We want non-textual, but we don't need to do so if the header including
      # you via include_next is non-textual.
      if header.prev is not None:
        header.textual = not header.prev.textual
      # Anything not to be included by the user directly that was only included
      # once can be marked as textual. Unfortunately since .d files calculate
      # *transitive* dependencies this is not particularly effective.
      elif (len(rdeps[header]) < 2
            and parts.intersection(['asm', 'asm-generic', 'bits'])):
        header.textual = True
      elif '#pragma once' in (header.content or ''):
        header.textual = False
      elif 'bits' in parts:
        header.textual = True

    # Assert is inherently textual.
    graph['assert.h'].textual = True

  force_textual('asm-generic/unistd.h')
  force_textual('asm-generic/bitsperlong.h')

  if compiler.os == Os.Android:
    graph['android/legacy_stdlib_inlines.h'].textual = True
    graph['android/legacy_threads_inlines.h'].textual = True
    graph['android/legacy_unistd_inlines.h'].textual = True
    graph['bits/threads_inlines.h'].textual = True

    graph['asm-generic/posix_types.h'].textual = True
    graph['asm/posix_types.h'].textual = True

    # sys/syscall.h includes asm/unistd.h, which includes
    # asm/unistd_<platform>.h, which defines some macros.
    # It then includes bits/glibc-syscalls.h which uses said macros, so both
    # must be non-textual.
    for k in graph:
      if k.startswith('asm/unistd'):
        graph[k].textual = True
    graph['bits/glibc-syscalls.h'].textual = True

  elif compiler.os == Os.Linux:
    # See https://codebrowser.dev/glibc/glibc/sysdeps/unix/sysv/linux/bits/local_lim.h.html#56
    # if linux/limits.h is non-textual, then limits.h undefs the limits.h
    # defined in the linux/limits.h module.
    # Thus, limits.h exports an undef.
    # if it's textual, limits.h undefs something it defined itself.
    graph['linux/limits.h'].textual = True

    # This is not included on arm32
    graph['asm-generic/types.h'].textual = True

    # On chromeos, x86_64-linux-gnu/foo.h will be either moved to foo.h or to
    # x86_64-cros-gnu.
    # So we just mark them all as textual so they don't appear in the modulemap.
    for hdr in graph.values():
      if '-linux-gnu' in str(hdr.abs):
        hdr.textual = True

  # Windows has multiple include directories contained with the sysroot.
  if compiler.os == Os.Win:
    graph['math.h'].kwargs['defines'].append('_USE_MATH_DEFINES')
    return {
        graph['corecrt.h'].abs.parent.parent: '$windows_kits',
        graph['eh.h'].abs.parent: '$msvc',
    }
  else:
    return {sysroot: '$sysroot'}


def should_compile(target: Target) -> bool:
  """Decides whether a target should be compiled or not.

  If this returns true, the target should be compiled.
  If this returns false, the target *may* be compiled (eg. if a target that
    should be compiled depends on this).
  """
  for header in target.headers:
    # For now, we only precompile the transitive dependencies of libcxx, and
    # nothing else in the sysroot.
    if header.include_dir == IncludeDir.LibCxx:
      return True

  return False