v8 152.0.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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

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

# This is a list of files from the sysroot that are allowed to included from
# chromium code.
# Instructions:
# * Keep this list in sorted order.
# * If you need custom attributes (except exists), please explain them with a
#   comment.

# Note that this is filtered to only headers that are actually present.
# ie. If you add 'android/foo.h', it will silently ignore it on non-android
# platforms.

import dataclasses
from typing import Optional


@dataclasses.dataclass
class Header:
  path: str
  # Textual headers are, instead of being precompiled, textually included just
  # like you normally would with #include without modules.
  # A header should be textual if it is intended to be included multiple times
  # with different preprocessor configurations in a single build.
  # A good signal for this is if the header is missing include guards.
  # Note: Textual headers are a formal term used by clang.
  # See https://clang.llvm.org/docs/Modules.html
  textual: Optional[bool] = None
  # Lazy headers are not added to the modulemap unless they are included by
  # another system header.
  lazy: bool = False
  # This specifies that the header only exists conditionally (eg. windows-only
  # headers). We could, instead of Header('foo', exists=is_win), write
  # *[Header('foo')] if is_win else [], but we provide this for simplicity's
  # sake.
  exists: bool = True
  # The name of the module for this header. Only useful for listing as an
  # export.
  module_name: Optional[str] = None
  # A list of module names that things that #include this header should gain
  # access to. If you specify *, then it gains access to anything in its direct
  # dependencies.
  exports: list[str] = dataclasses.field(default_factory=lambda: ['*'])

  # If true, will force the header to create itself even if it wasn't in the
  # depfile.
  force: bool = False

  # If true, the header will be marked private.
  # Note: If a header is both textual and private, it will not be added to the
  # modulemap.
  private: bool = False


# An allowed header is one that is here purely to add it to the allowlist of
# files to #include. It is not precompiled.
class AllowedHeader(Header):

  def __init__(self, path: str, exists: bool = True):
    super().__init__(path, force=True, lazy=True, exists=exists)


def headers(os):
  is_linux = os == 'linux'
  is_android = os == 'android'
  is_ios = os == 'ios'
  is_mac = os == 'mac'
  is_apple = os == 'mac' or os == 'ios'
  is_fuchsia = os == 'fuchsia'
  is_win = os == 'win'
  is_chromeos = os == 'chromeos'

  # Keep this list of headers alphabetically sorted, but comments should remain
  # attached to the entry under them, and blank lines should be preserved.

  return [
      Header('alloca.h'),
      # Include loop with sys/cdefs.h
      Header('android/api-level.h', exists=is_android, textual=True),
      Header('android/legacy_stdlib_inlines.h', textual=True),
      Header('android/ndk-version.h', exists=is_android),
      Header('android/versioning.h', exists=is_android),
      AllowedHeader('arpa/inet.h'),
      Header('asm/fcntl.h', module_name='asm_fcntl', exists=is_android),
      AllowedHeader('asm/hwcap.h'),
      Header('asm/ioctl.h', lazy=True, textual=True),
      AllowedHeader('asm/ptrace.h'),
      Header('asm/sigcontext.h', lazy=True),
      Header('asm/unistd.h'),
      Header('asm/unistd_64.h'),
      Header('asm-generic/errno-base.h'),
      Header('asm-generic/errno.h'),
      Header('asm-generic/fcntl.h',
             module_name='asm_generic_fcntl',
             exists=is_android),
      Header('asm-generic/ioctl.h', module_name='asm_generic_ioctl', lazy=True),
      Header('asm-generic/ioctls.h',
             module_name='asm_generic_ioctls',
             lazy=True),
      # We need posix_types_32.h to define __kernel_mode_t in the same TU.
      # This way it appears as an override rather than a second definition.
      Header('asm-generic/posix_types.h', textual=True, lazy=True),
      Header('asm-generic/unistd.h'),
      # Inherently textual
      Header('assert.h', textual=True),
      # avx512 headers are missing from clang modulemap.
      Header('avx512dqintrin.h', textual=True, lazy=True),
      Header('bits/fcntl.h', module_name='bits_fcntl', exists=is_android),
      Header('bits/getopt.h', module_name='bits_getopt', lazy=True),
      Header('bits/ioctl.h', module_name='bits_ioctl', lazy=True),
      # This isn't guarded, so it needs to be textual to prevent duplicate
      # definitions.
      Header('bits/mbstate_t.h', textual=False, lazy=True),
      # If this is textual it complains that pid_types isn't accessible from
      # sched.h
      Header('bits/timespec.h', textual=False, lazy=True),
      # We need to re-export std::mbstate_t in std.std_mbstate_t.
      Header('corecrt.h', exists=is_win, module_name='corecrt'),
      # We need to re-export wcsstr in a few places.
      Header('corecrt_wstring.h', exists=is_win, module_name='corecrt_wstring'),
      Header('ctype.h'),
      Header('cxxabi.h'),
      AllowedHeader('dirent.h'),
      AllowedHeader('dlfcn.h'),
      AllowedHeader('elf.h'),
      Header('endian.h'),
      # POSIX standard says that fcntl.h must re-export most dependencies.
      Header('fcntl.h',
             exports=[
                 '*', 'asm_fcntl', 'asm_generic_fcntl', 'bits_fcntl',
                 'linux_fadvise', 'linux_fcntl'
             ]),
      Header('features.h'),
      Header('fenv.h'),
      Header('getopt.h', exports=['bits_getopt']),
      AllowedHeader('grp.h'),
      AllowedHeader('libgen.h'),
      # 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.
      Header('limits.h', textual=True),
      AllowedHeader('link.h'),
      Header('linux/fadvise.h', module_name='linux_fadvise'),
      AllowedHeader('linux/futex.h'),
      Header('linux/ioctl.h'),
      # See above comment about limits.h
      Header('linux/limits.h', textual=True),
      AllowedHeader('linux/posix_types.h'),
      AllowedHeader('linux/random.h'),
      AllowedHeader('linux/sched.h'),
      # On ChromeOS, linux/sched/types.h defines struct sched_param and
      # conflicts with the definition in bits/types/struct_sched_param.h. We
      # mark it private and textual to prevent the conflict.
      Header('linux/sched/types.h', textual=True, private=True),
      Header('linux/fcntl.h', module_name='linux_fcntl'),
      Header('linux/stat.h', module_name='linux_stat'),
      Header('linux/types.h'),
      Header('linux/unistd.h'),
      Header('locale.h'),
      Header('malloc.h'),
      AllowedHeader('netdb.h'),
      AllowedHeader('netinet/in.h'),
      AllowedHeader('netinet/tcp.h'),
      # We need to re-export std::nothrow in std.new
      Header('new.h', exists=is_win, module_name='new_h'),
      AllowedHeader('poll.h'),
      Header('pthread.h'),
      Header('sal.h', exists=is_win),
      Header('sched.h'),
      AllowedHeader('semaphore.h'),
      Header('setjmp.h'),
      Header('signal.h'),
      # corecrt_wstring needs to be exported since it provides wcscmp
      Header('string.h', exists=is_win, exports=['*', 'corecrt_wstring']),
      Header('strings.h'),
      # In an include loop with features.h, but not on android
      AllowedHeader('sys/auxv.h'),
      Header('sys/cdefs.h', textual=not is_android),
      AllowedHeader('sys/eventfd.h'),
      AllowedHeader('sys/inotify.h'),
      Header('sys/ioctl.h',
             exports=['asm_generic_ioctl', 'asm_generic_ioctls', 'bits_ioctl']),
      AllowedHeader('sys/mman.h'),
      AllowedHeader('sys/prctl.h'),
      Header('sys/procfs.h'),
      AllowedHeader('sys/ptrace.h'),
      AllowedHeader('sys/resource.h'),
      Header('sys/select.h'),
      AllowedHeader('sys/socket.h'),
      Header('sys/stat.h', exports=['linux_stat']),
      Header('sys/time.h'),
      AllowedHeader('sys/syscall.h'),
      AllowedHeader('sys/sysinfo.h'),
      AllowedHeader('sys/time.h'),
      AllowedHeader('sys/timerfd.h'),
      Header('sys/types.h'),
      Header('sys/ucontext.h'),
      AllowedHeader('sys/un.h'),
      Header('sys/user.h'),
      AllowedHeader('sys/utsname.h'),
      AllowedHeader('sys/wait.h'),
      AllowedHeader('syscall.h'),
      Header('time.h'),
      AllowedHeader('ucontext.h'),
      # Unistd re-exports basically everything it #includes
      Header('unistd.h', exports=['*', 'bits_getopt']),
      # Sysroot unwind.h should only ever be included by clang's unwind.h
      Header('unwind.h', textual=True, private=True),
      # We need to re-export std::exception in std.exception.exception and type
      # info.
      Header('vcruntime_exception.h',
             exists=is_win,
             module_name='vcruntime_exception'),
      # We need to re-export std::align_val_t in std.new.align_val_t.
      Header('vcruntime_new.h', exists=is_win, module_name='vcruntime_new'),
      # We need to re-export RTTI types (std::type_info, std::bad_cast, etc.)
      # in std.typeinfo.
      Header('vcruntime_typeinfo.h',
             exists=is_win,
             module_name='vcruntime_typeinfo',
             exports=['*', 'vcruntime_exception']),
      # include_next works differently with modules. This makes wchar.h and
      # mbstate_t.h an include loop.
      # This needs to be nontextual on windows, since otherwise it appears under
      # cwchar.
      Header('wchar.h', textual=not is_win),
      Header('winapifamily.h', exists=is_win),
  ]