GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/env-inl.h Lines: 600 605 99.2 %
Date: 2019-09-23 22:30:09 Branches: 83 116 71.6 %

Line Branch Exec Source
1
// Copyright Joyent, Inc. and other Node contributors.
2
//
3
// Permission is hereby granted, free of charge, to any person obtaining a
4
// copy of this software and associated documentation files (the
5
// "Software"), to deal in the Software without restriction, including
6
// without limitation the rights to use, copy, modify, merge, publish,
7
// distribute, sublicense, and/or sell copies of the Software, and to permit
8
// persons to whom the Software is furnished to do so, subject to the
9
// following conditions:
10
//
11
// The above copyright notice and this permission notice shall be included
12
// in all copies or substantial portions of the Software.
13
//
14
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20
// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22
#ifndef SRC_ENV_INL_H_
23
#define SRC_ENV_INL_H_
24
25
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
26
27
#include "aliased_buffer.h"
28
#include "env.h"
29
#include "node.h"
30
#include "util-inl.h"
31
#include "uv.h"
32
#include "v8.h"
33
#include "node_perf_common.h"
34
#include "node_context_data.h"
35
36
#include <cstddef>
37
#include <cstdint>
38
39
#include <utility>
40
41
namespace node {
42
43
10914
inline v8::Isolate* IsolateData::isolate() const {
44
10914
  return isolate_;
45
}
46
47
1559620
inline uv_loop_t* IsolateData::event_loop() const {
48
1559620
  return event_loop_;
49
}
50
51
326261
inline bool IsolateData::uses_node_allocator() const {
52
326261
  return uses_node_allocator_;
53
}
54
55
666838
inline v8::ArrayBuffer::Allocator* IsolateData::allocator() const {
56
666838
  return allocator_;
57
}
58
59
331970
inline NodeArrayBufferAllocator* IsolateData::node_allocator() const {
60
331970
  return node_allocator_;
61
}
62
63
273193
inline MultiIsolatePlatform* IsolateData::platform() const {
64
273193
  return platform_;
65
}
66
67
5194
inline AsyncHooks::AsyncHooks()
68
    : async_ids_stack_(env()->isolate(), 16 * 2),
69
      fields_(env()->isolate(), kFieldsCount),
70
5194
      async_id_fields_(env()->isolate(), kUidFieldsCount) {
71
5194
  v8::HandleScope handle_scope(env()->isolate());
72
73
  // Always perform async_hooks checks, not just when async_hooks is enabled.
74
  // TODO(AndreasMadsen): Consider removing this for LTS releases.
75
  // See discussion in https://github.com/nodejs/node/pull/15454
76
  // When removing this, do it by reverting the commit. Otherwise the test
77
  // and flag changes won't be included.
78
5194
  fields_[kCheck] = 1;
79
80
  // kDefaultTriggerAsyncId should be -1, this indicates that there is no
81
  // specified default value and it should fallback to the executionAsyncId.
82
  // 0 is not used as the magic value, because that indicates a missing context
83
  // which is different from a default context.
84
5194
  async_id_fields_[AsyncHooks::kDefaultTriggerAsyncId] = -1;
85
86
  // kAsyncIdCounter should start at 1 because that'll be the id the execution
87
  // context during bootstrap (code that runs before entering uv_run()).
88
5194
  async_id_fields_[AsyncHooks::kAsyncIdCounter] = 1;
89
90
  // Create all the provider strings that will be passed to JS. Place them in
91
  // an array so the array index matches the PROVIDER id offset. This way the
92
  // strings can be retrieved quickly.
93
#define V(Provider)                                                           \
94
  providers_[AsyncWrap::PROVIDER_ ## Provider].Set(                           \
95
      env()->isolate(),                                                       \
96
      v8::String::NewFromOneByte(                                             \
97
        env()->isolate(),                                                     \
98
        reinterpret_cast<const uint8_t*>(#Provider),                          \
99
        v8::NewStringType::kInternalized,                                     \
100
        sizeof(#Provider) - 1).ToLocalChecked());
101
462266
  NODE_ASYNC_PROVIDER_TYPES(V)
102
#undef V
103
5194
}
104
4985271
inline AliasedUint32Array& AsyncHooks::fields() {
105
4985271
  return fields_;
106
}
107
108
4699040
inline AliasedFloat64Array& AsyncHooks::async_id_fields() {
109
4699040
  return async_id_fields_;
110
}
111
112
5193
inline AliasedFloat64Array& AsyncHooks::async_ids_stack() {
113
5193
  return async_ids_stack_;
114
}
115
116
318431
inline v8::Local<v8::String> AsyncHooks::provider_string(int idx) {
117
636862
  return providers_[idx].Get(env()->isolate());
118
}
119
120
1
inline void AsyncHooks::no_force_checks() {
121
1
  fields_[kCheck] -= 1;
122
1
}
123
124
796300
inline Environment* AsyncHooks::env() {
125
796300
  return Environment::ForAsyncHooks(this);
126
}
127
128
// Remember to keep this code aligned with pushAsyncIds() in JS.
129
1194456
inline void AsyncHooks::push_async_ids(double async_id,
130
                                       double trigger_async_id) {
131
  // Since async_hooks is experimental, do only perform the check
132
  // when async_hooks is enabled.
133
1194456
  if (fields_[kCheck] > 0) {
134
1194457
    CHECK_GE(async_id, -1);
135
1194457
    CHECK_GE(trigger_async_id, -1);
136
  }
137
138
1194533
  uint32_t offset = fields_[kStackLength];
139
1194520
  if (offset * 2 >= async_ids_stack_.Length())
140
8
    grow_async_ids_stack();
141
1194471
  async_ids_stack_[2 * offset] = async_id_fields_[kExecutionAsyncId];
142
1194520
  async_ids_stack_[2 * offset + 1] = async_id_fields_[kTriggerAsyncId];
143
1194497
  fields_[kStackLength] += 1;
144
1194505
  async_id_fields_[kExecutionAsyncId] = async_id;
145
1194498
  async_id_fields_[kTriggerAsyncId] = trigger_async_id;
146
1194499
}
147
148
// Remember to keep this code aligned with popAsyncIds() in JS.
149
1194165
inline bool AsyncHooks::pop_async_id(double async_id) {
150
  // In case of an exception then this may have already been reset, if the
151
  // stack was multiple MakeCallback()'s deep.
152
1194165
  if (fields_[kStackLength] == 0) return false;
153
154
  // Ask for the async_id to be restored as a check that the stack
155
  // hasn't been corrupted.
156
  // Since async_hooks is experimental, do only perform the check
157
  // when async_hooks is enabled.
158


1193547
  if (fields_[kCheck] > 0 && async_id_fields_[kExecutionAsyncId] != async_id) {
159
    fprintf(stderr,
160
            "Error: async hook stack has become corrupted ("
161
            "actual: %.f, expected: %.f)\n",
162
            async_id_fields_.GetValue(kExecutionAsyncId),
163
4
            async_id);
164
4
    DumpBacktrace(stderr);
165
4
    fflush(stderr);
166
4
    if (!env()->abort_on_uncaught_exception())
167
4
      exit(1);
168
    fprintf(stderr, "\n");
169
    fflush(stderr);
170
    ABORT_NO_BACKTRACE();
171
  }
172
173
1193544
  uint32_t offset = fields_[kStackLength] - 1;
174
1193548
  async_id_fields_[kExecutionAsyncId] = async_ids_stack_[2 * offset];
175
1193545
  async_id_fields_[kTriggerAsyncId] = async_ids_stack_[2 * offset + 1];
176
1193544
  fields_[kStackLength] = offset;
177
178
1193543
  return fields_[kStackLength] > 0;
179
}
180
181
// Keep in sync with clearAsyncIdStack in lib/internal/async_hooks.js.
182
29
inline void AsyncHooks::clear_async_id_stack() {
183
29
  async_id_fields_[kExecutionAsyncId] = 0;
184
29
  async_id_fields_[kTriggerAsyncId] = 0;
185
29
  fields_[kStackLength] = 0;
186
29
}
187
188
// The DefaultTriggerAsyncIdScope(AsyncWrap*) constructor is defined in
189
// async_wrap-inl.h to avoid a circular dependency.
190
191
1162584
inline AsyncHooks::DefaultTriggerAsyncIdScope ::DefaultTriggerAsyncIdScope(
192
    Environment* env, double default_trigger_async_id)
193
1162584
    : async_hooks_(env->async_hooks()) {
194
1162584
  if (env->async_hooks()->fields()[AsyncHooks::kCheck] > 0) {
195
1162584
    CHECK_GE(default_trigger_async_id, 0);
196
  }
197
198
2325168
  old_default_trigger_async_id_ =
199
2325168
    async_hooks_->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId];
200
2325168
  async_hooks_->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] =
201
1162584
    default_trigger_async_id;
202
1162584
}
203
204
1162583
inline AsyncHooks::DefaultTriggerAsyncIdScope ::~DefaultTriggerAsyncIdScope() {
205
2325166
  async_hooks_->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] =
206
1162583
    old_default_trigger_async_id_;
207
1162583
}
208
209
210
796299
Environment* Environment::ForAsyncHooks(AsyncHooks* hooks) {
211
796299
  return ContainerOf(&Environment::async_hooks_, hooks);
212
}
213
214
1449037
inline AsyncCallbackScope::AsyncCallbackScope(Environment* env) : env_(env) {
215
1449037
  env_->PushAsyncCallbackScope();
216
1449254
}
217
218
1448954
inline AsyncCallbackScope::~AsyncCallbackScope() {
219
1448954
  env_->PopAsyncCallbackScope();
220
1448953
}
221
222
1189246
inline size_t Environment::async_callback_scope_depth() const {
223
1189246
  return async_callback_scope_depth_;
224
}
225
226
1448975
inline void Environment::PushAsyncCallbackScope() {
227
1448975
  async_callback_scope_depth_++;
228
1448975
}
229
230
1448954
inline void Environment::PopAsyncCallbackScope() {
231
1448954
  async_callback_scope_depth_--;
232
1448954
}
233
234
5194
inline ImmediateInfo::ImmediateInfo(v8::Isolate* isolate)
235
5194
    : fields_(isolate, kFieldsCount) {}
236
237
5194
inline AliasedUint32Array& ImmediateInfo::fields() {
238
5194
  return fields_;
239
}
240
241
446257
inline uint32_t ImmediateInfo::count() const {
242
446257
  return fields_[kCount];
243
}
244
245
88171
inline uint32_t ImmediateInfo::ref_count() const {
246
88171
  return fields_[kRefCount];
247
}
248
249
55936
inline bool ImmediateInfo::has_outstanding() const {
250
55936
  return fields_[kHasOutstanding] == 1;
251
}
252
253
55005
inline void ImmediateInfo::count_inc(uint32_t increment) {
254
55005
  fields_[kCount] += increment;
255
55005
}
256
257
55423
inline void ImmediateInfo::count_dec(uint32_t decrement) {
258
55423
  fields_[kCount] -= decrement;
259
55423
}
260
261
32756
inline void ImmediateInfo::ref_count_inc(uint32_t increment) {
262
32756
  fields_[kRefCount] += increment;
263
32756
}
264
265
55423
inline void ImmediateInfo::ref_count_dec(uint32_t decrement) {
266
55423
  fields_[kRefCount] -= decrement;
267
55423
}
268
269
5194
inline TickInfo::TickInfo(v8::Isolate* isolate)
270
5194
    : fields_(isolate, kFieldsCount) {}
271
272
5193
inline AliasedUint8Array& TickInfo::fields() {
273
5193
  return fields_;
274
}
275
276
1796549
inline bool TickInfo::has_tick_scheduled() const {
277
1796549
  return fields_[kHasTickScheduled] == 1;
278
}
279
280
300808
inline bool TickInfo::has_rejection_to_warn() const {
281
300808
  return fields_[kHasRejectionToWarn] == 1;
282
}
283
284
5655
inline void Environment::AssignToContext(v8::Local<v8::Context> context,
285
                                         const ContextInfo& info) {
286
  context->SetAlignedPointerInEmbedderData(
287
5655
      ContextEmbedderIndex::kEnvironment, this);
288
  // Used by Environment::GetCurrent to know that we are on a node context.
289
  context->SetAlignedPointerInEmbedderData(
290
11308
    ContextEmbedderIndex::kContextTag, Environment::kNodeContextTagPtr);
291
#if HAVE_INSPECTOR
292
5655
  inspector_agent()->ContextCreated(context, info);
293
#endif  // HAVE_INSPECTOR
294
5655
}
295
296
1218167
inline Environment* Environment::GetCurrent(v8::Isolate* isolate) {
297
1218167
  if (UNLIKELY(!isolate->InContext())) return nullptr;
298
1218350
  v8::HandleScope handle_scope(isolate);
299
1218436
  return GetCurrent(isolate->GetCurrentContext());
300
}
301
302
1537901
inline Environment* Environment::GetCurrent(v8::Local<v8::Context> context) {
303
1537901
  if (UNLIKELY(context.IsEmpty())) {
304
    return nullptr;
305
  }
306
1537901
  if (UNLIKELY(context->GetNumberOfEmbedderDataFields() <=
307
               ContextEmbedderIndex::kContextTag)) {
308
1
    return nullptr;
309
  }
310
3076330
  if (UNLIKELY(context->GetAlignedPointerFromEmbedderData(
311
                   ContextEmbedderIndex::kContextTag) !=
312
               Environment::kNodeContextTagPtr)) {
313
    return nullptr;
314
  }
315
  return static_cast<Environment*>(
316
      context->GetAlignedPointerFromEmbedderData(
317
3076330
          ContextEmbedderIndex::kEnvironment));
318
}
319
320
9511467
inline Environment* Environment::GetCurrent(
321
    const v8::FunctionCallbackInfo<v8::Value>& info) {
322
9511467
  return GetFromCallbackData(info.Data());
323
}
324
325
template <typename T>
326
2741349
inline Environment* Environment::GetCurrent(
327
    const v8::PropertyCallbackInfo<T>& info) {
328
2741349
  return GetFromCallbackData(info.Data());
329
}
330
331
12252825
inline Environment* Environment::GetFromCallbackData(v8::Local<v8::Value> val) {
332
  DCHECK(val->IsObject());
333
12252825
  v8::Local<v8::Object> obj = val.As<v8::Object>();
334
  DCHECK_GE(obj->InternalFieldCount(), 1);
335
  Environment* env =
336
24505649
      static_cast<Environment*>(obj->GetAlignedPointerFromInternalField(0));
337
  DCHECK(env->as_callback_data_template()->HasInstance(obj));
338
12252824
  return env;
339
}
340
341
7
inline Environment* Environment::GetThreadLocalEnv() {
342
7
  return static_cast<Environment*>(uv_key_get(&thread_local_env));
343
}
344
345
217
inline bool Environment::profiler_idle_notifier_started() const {
346
217
  return profiler_idle_notifier_started_;
347
}
348
349
70978587
inline v8::Isolate* Environment::isolate() const {
350
70978587
  return isolate_;
351
}
352
353
5177
inline Environment* Environment::from_timer_handle(uv_timer_t* handle) {
354
5177
  return ContainerOf(&Environment::timer_handle_, handle);
355
}
356
357
23148
inline uv_timer_t* Environment::timer_handle() {
358
23148
  return &timer_handle_;
359
}
360
361
446258
inline Environment* Environment::from_immediate_check_handle(
362
    uv_check_t* handle) {
363
446258
  return ContainerOf(&Environment::immediate_check_handle_, handle);
364
}
365
366
20776
inline uv_check_t* Environment::immediate_check_handle() {
367
20776
  return &immediate_check_handle_;
368
}
369
370
90692
inline uv_idle_t* Environment::immediate_idle_handle() {
371
90692
  return &immediate_idle_handle_;
372
}
373
374
25970
inline void Environment::RegisterHandleCleanup(uv_handle_t* handle,
375
                                               HandleCleanupCb cb,
376
                                               void* arg) {
377
25970
  handle_cleanup_queue_.push_back(HandleCleanup{handle, cb, arg});
378
25970
}
379
380
template <typename T, typename OnCloseCallback>
381
29101
inline void Environment::CloseHandle(T* handle, OnCloseCallback callback) {
382
29101
  handle_cleanup_waiting_++;
383
  static_assert(sizeof(T) >= sizeof(uv_handle_t), "T is a libuv handle");
384
  static_assert(offsetof(T, data) == offsetof(uv_handle_t, data),
385
                "T is a libuv handle");
386
  static_assert(offsetof(T, close_cb) == offsetof(uv_handle_t, close_cb),
387
                "T is a libuv handle");
388
  struct CloseData {
389
    Environment* env;
390
    OnCloseCallback callback;
391
    void* original_data;
392
  };
393
29101
  handle->data = new CloseData { this, callback, handle->data };
394
116354
  uv_close(reinterpret_cast<uv_handle_t*>(handle), [](uv_handle_t* handle) {
395
29076
    std::unique_ptr<CloseData> data { static_cast<CloseData*>(handle->data) };
396
29076
    data->env->handle_cleanup_waiting_--;
397
29076
    handle->data = data->original_data;
398
29076
    data->callback(reinterpret_cast<T*>(handle));
399
87278
  });
400
29101
}
401
402
120527
void Environment::IncreaseWaitingRequestCounter() {
403
120527
  request_waiting_++;
404
120527
}
405
406
120461
void Environment::DecreaseWaitingRequestCounter() {
407
120461
  request_waiting_--;
408
120461
  CHECK_GE(request_waiting_, 0);
409
120461
}
410
411
1554426
inline uv_loop_t* Environment::event_loop() const {
412
1554426
  return isolate_data()->event_loop();
413
}
414
415
151
inline void Environment::TryLoadAddon(
416
    const char* filename,
417
    int flags,
418
    const std::function<bool(binding::DLib*)>& was_loaded) {
419
151
  loaded_addons_.emplace_back(filename, flags);
420
151
  if (!was_loaded(&loaded_addons_.back())) {
421
7
    loaded_addons_.pop_back();
422
  }
423
151
}
424
425
#if HAVE_INSPECTOR
426
268713
inline bool Environment::is_in_inspector_console_call() const {
427
268713
  return is_in_inspector_console_call_;
428
}
429
430
537424
inline void Environment::set_is_in_inspector_console_call(bool value) {
431
537424
  is_in_inspector_console_call_ = value;
432
537424
}
433
#endif
434
435
10070745
inline AsyncHooks* Environment::async_hooks() {
436
10070745
  return &async_hooks_;
437
}
438
439
794164
inline ImmediateInfo* Environment::immediate_info() {
440
794164
  return &immediate_info_;
441
}
442
443
903477
inline TickInfo* Environment::tick_info() {
444
903477
  return &tick_info_;
445
}
446
447
511598
inline uint64_t Environment::timer_base() const {
448
511598
  return timer_base_;
449
}
450
451
2756305
inline std::shared_ptr<KVStore> Environment::env_vars() {
452
2756305
  return env_vars_;
453
}
454
455
5400
inline void Environment::set_env_vars(std::shared_ptr<KVStore> env_vars) {
456
5400
  env_vars_ = env_vars;
457
5399
}
458
459
11
inline bool Environment::printed_error() const {
460
11
  return printed_error_;
461
}
462
463
11
inline void Environment::set_printed_error(bool value) {
464
11
  printed_error_ = value;
465
11
}
466
467
9318
inline void Environment::set_trace_sync_io(bool value) {
468
9318
  trace_sync_io_ = value;
469
9318
}
470
471
30
inline bool Environment::abort_on_uncaught_exception() const {
472
30
  return options_->abort_on_uncaught_exception;
473
}
474
475
206
inline void Environment::set_abort_on_uncaught_exception(bool value) {
476
206
  options_->abort_on_uncaught_exception = value;
477
206
}
478
479
5223
inline AliasedUint32Array& Environment::should_abort_on_uncaught_toggle() {
480
5223
  return should_abort_on_uncaught_toggle_;
481
}
482
483
2593574
inline AliasedInt32Array& Environment::stream_base_state() {
484
2593574
  return stream_base_state_;
485
}
486
487
432
inline uint32_t Environment::get_next_module_id() {
488
432
  return module_id_counter_++;
489
}
490
2076
inline uint32_t Environment::get_next_script_id() {
491
2076
  return script_id_counter_++;
492
}
493
39904
inline uint32_t Environment::get_next_function_id() {
494
39904
  return function_id_counter_++;
495
}
496
497
2655
ShouldNotAbortOnUncaughtScope::ShouldNotAbortOnUncaughtScope(
498
    Environment* env)
499
2655
    : env_(env) {
500
2655
  env_->PushShouldNotAbortOnUncaughtScope();
501
2655
}
502
503
2653
ShouldNotAbortOnUncaughtScope::~ShouldNotAbortOnUncaughtScope() {
504
2653
  Close();
505
2653
}
506
507
2854
void ShouldNotAbortOnUncaughtScope::Close() {
508
2854
  if (env_ != nullptr) {
509
2653
    env_->PopShouldNotAbortOnUncaughtScope();
510
2653
    env_ = nullptr;
511
  }
512
2854
}
513
514
2655
inline void Environment::PushShouldNotAbortOnUncaughtScope() {
515
2655
  should_not_abort_scope_counter_++;
516
2655
}
517
518
2653
inline void Environment::PopShouldNotAbortOnUncaughtScope() {
519
2653
  should_not_abort_scope_counter_--;
520
2653
}
521
522
1
inline bool Environment::inside_should_not_abort_on_uncaught_scope() const {
523
1
  return should_not_abort_scope_counter_ > 0;
524
}
525
526
191645
inline std::vector<double>* Environment::destroy_async_id_list() {
527
191645
  return &destroy_async_id_list_;
528
}
529
530
318994
inline double Environment::new_async_id() {
531
318994
  async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter] += 1;
532
318994
  return async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter];
533
}
534
535
211615
inline double Environment::execution_async_id() {
536
211615
  return async_hooks()->async_id_fields()[AsyncHooks::kExecutionAsyncId];
537
}
538
539
37513
inline double Environment::trigger_async_id() {
540
37513
  return async_hooks()->async_id_fields()[AsyncHooks::kTriggerAsyncId];
541
}
542
543
318991
inline double Environment::get_default_trigger_async_id() {
544
  double default_trigger_async_id =
545
318991
    async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId];
546
  // If defaultTriggerAsyncId isn't set, use the executionAsyncId
547
318991
  if (default_trigger_async_id < 0)
548
173609
    default_trigger_async_id = execution_async_id();
549
318991
  return default_trigger_async_id;
550
}
551
552
70
inline double* Environment::heap_statistics_buffer() const {
553
70
  CHECK_NOT_NULL(heap_statistics_buffer_);
554
70
  return heap_statistics_buffer_;
555
}
556
557
68
inline void Environment::set_heap_statistics_buffer(double* pointer) {
558
68
  CHECK_NULL(heap_statistics_buffer_);  // Should be set only once.
559
68
  heap_statistics_buffer_ = pointer;
560
68
}
561
562
69
inline double* Environment::heap_space_statistics_buffer() const {
563
69
  CHECK_NOT_NULL(heap_space_statistics_buffer_);
564
69
  return heap_space_statistics_buffer_;
565
}
566
567
68
inline void Environment::set_heap_space_statistics_buffer(double* pointer) {
568
68
  CHECK_NULL(heap_space_statistics_buffer_);  // Should be set only once.
569
68
  heap_space_statistics_buffer_ = pointer;
570
68
}
571
572
69
inline double* Environment::heap_code_statistics_buffer() const {
573
69
  CHECK_NOT_NULL(heap_code_statistics_buffer_);
574
69
  return heap_code_statistics_buffer_;
575
}
576
577
68
inline void Environment::set_heap_code_statistics_buffer(double* pointer) {
578
68
  CHECK_NULL(heap_code_statistics_buffer_);  // Should be set only once.
579
68
  heap_code_statistics_buffer_ = pointer;
580
68
}
581
582
407479
inline char* Environment::http_parser_buffer() const {
583
407479
  return http_parser_buffer_;
584
}
585
586
294
inline void Environment::set_http_parser_buffer(char* buffer) {
587
294
  CHECK_NULL(http_parser_buffer_);  // Should be set only once.
588
294
  http_parser_buffer_ = buffer;
589
294
}
590
591
135822
inline bool Environment::http_parser_buffer_in_use() const {
592
135822
  return http_parser_buffer_in_use_;
593
}
594
595
271640
inline void Environment::set_http_parser_buffer_in_use(bool in_use) {
596
271640
  http_parser_buffer_in_use_ = in_use;
597
271640
}
598
599
1711
inline http2::Http2State* Environment::http2_state() const {
600
1711
  return http2_state_.get();
601
}
602
603
232
inline void Environment::set_http2_state(
604
    std::unique_ptr<http2::Http2State> buffer) {
605
232
  CHECK(!http2_state_);  // Should be set only once.
606
232
  http2_state_ = std::move(buffer);
607
232
}
608
609
1226535
bool Environment::debug_enabled(DebugCategory category) const {
610
  DCHECK_GE(static_cast<int>(category), 0);
611
  DCHECK_LT(static_cast<int>(category),
612
           static_cast<int>(DebugCategory::CATEGORY_COUNT));
613
1226535
  return debug_enabled_[static_cast<int>(category)];
614
}
615
616
22
void Environment::set_debug_enabled(DebugCategory category, bool enabled) {
617
  DCHECK_GE(static_cast<int>(category), 0);
618
  DCHECK_LT(static_cast<int>(category),
619
           static_cast<int>(DebugCategory::CATEGORY_COUNT));
620
22
  debug_enabled_[static_cast<int>(category)] = enabled;
621
22
}
622
623
212263
inline AliasedFloat64Array* Environment::fs_stats_field_array() {
624
212263
  return &fs_stats_field_array_;
625
}
626
627
5203
inline AliasedBigUint64Array* Environment::fs_stats_field_bigint_array() {
628
5203
  return &fs_stats_field_bigint_array_;
629
}
630
631
inline std::vector<std::unique_ptr<fs::FileHandleReadWrap>>&
632
442
Environment::file_handle_read_wrap_freelist() {
633
442
  return file_handle_read_wrap_freelist_;
634
}
635
636
55346
inline std::shared_ptr<EnvironmentOptions> Environment::options() {
637
55346
  return options_;
638
}
639
640
15025
inline const std::vector<std::string>& Environment::argv() {
641
15025
  return argv_;
642
}
643
644
5401
inline const std::vector<std::string>& Environment::exec_argv() {
645
5401
  return exec_argv_;
646
}
647
648
10386
inline const std::string& Environment::exec_path() const {
649
10386
  return exec_path_;
650
}
651
652
#if HAVE_INSPECTOR
653
5188
inline void Environment::set_coverage_directory(const char* dir) {
654
5188
  coverage_directory_ = std::string(dir);
655
5188
}
656
657
5184
inline void Environment::set_coverage_connection(
658
    std::unique_ptr<profiler::V8CoverageConnection> connection) {
659
5184
  CHECK_NULL(coverage_connection_);
660
5184
  std::swap(coverage_connection_, connection);
661
5184
}
662
663
15464
inline profiler::V8CoverageConnection* Environment::coverage_connection() {
664
15464
  return coverage_connection_.get();
665
}
666
667
4981
inline const std::string& Environment::coverage_directory() const {
668
4981
  return coverage_directory_;
669
}
670
671
10
inline void Environment::set_cpu_profiler_connection(
672
    std::unique_ptr<profiler::V8CpuProfilerConnection> connection) {
673
10
  CHECK_NULL(cpu_profiler_connection_);
674
10
  std::swap(cpu_profiler_connection_, connection);
675
10
}
676
677
inline profiler::V8CpuProfilerConnection*
678
5116
Environment::cpu_profiler_connection() {
679
5116
  return cpu_profiler_connection_.get();
680
}
681
682
10
inline void Environment::set_cpu_prof_interval(uint64_t interval) {
683
10
  cpu_prof_interval_ = interval;
684
10
}
685
686
10
inline uint64_t Environment::cpu_prof_interval() const {
687
10
  return cpu_prof_interval_;
688
}
689
690
10
inline void Environment::set_cpu_prof_name(const std::string& name) {
691
10
  cpu_prof_name_ = name;
692
10
}
693
694
10
inline const std::string& Environment::cpu_prof_name() const {
695
10
  return cpu_prof_name_;
696
}
697
698
10
inline void Environment::set_cpu_prof_dir(const std::string& dir) {
699
10
  cpu_prof_dir_ = dir;
700
10
}
701
702
10
inline const std::string& Environment::cpu_prof_dir() const {
703
10
  return cpu_prof_dir_;
704
}
705
706
10
inline void Environment::set_heap_profiler_connection(
707
    std::unique_ptr<profiler::V8HeapProfilerConnection> connection) {
708
10
  CHECK_NULL(heap_profiler_connection_);
709
10
  std::swap(heap_profiler_connection_, connection);
710
10
}
711
712
inline profiler::V8HeapProfilerConnection*
713
5106
Environment::heap_profiler_connection() {
714
5106
  return heap_profiler_connection_.get();
715
}
716
717
10
inline void Environment::set_heap_prof_name(const std::string& name) {
718
10
  heap_prof_name_ = name;
719
10
}
720
721
10
inline const std::string& Environment::heap_prof_name() const {
722
10
  return heap_prof_name_;
723
}
724
725
10
inline void Environment::set_heap_prof_dir(const std::string& dir) {
726
10
  heap_prof_dir_ = dir;
727
10
}
728
729
10
inline const std::string& Environment::heap_prof_dir() const {
730
10
  return heap_prof_dir_;
731
}
732
733
10
inline void Environment::set_heap_prof_interval(uint64_t interval) {
734
10
  heap_prof_interval_ = interval;
735
10
}
736
737
10
inline uint64_t Environment::heap_prof_interval() const {
738
10
  return heap_prof_interval_;
739
}
740
741
#endif  // HAVE_INSPECTOR
742
743
10472
inline std::shared_ptr<HostPort> Environment::inspector_host_port() {
744
10472
  return inspector_host_port_;
745
}
746
747
16824
inline std::shared_ptr<PerIsolateOptions> IsolateData::options() {
748
16824
  return options_;
749
}
750
751
9
inline void IsolateData::set_options(
752
    std::shared_ptr<PerIsolateOptions> options) {
753
9
  options_ = std::move(options);
754
9
}
755
756
template <typename Fn>
757
55005
void Environment::CreateImmediate(Fn&& cb,
758
                                  v8::Local<v8::Object> keep_alive,
759
                                  bool ref) {
760
  auto callback = std::make_unique<NativeImmediateCallbackImpl<Fn>>(
761
55005
      std::move(cb),
762
      v8::Global<v8::Object>(isolate(), keep_alive),
763
165015
      ref);
764
55005
  NativeImmediateCallback* prev_tail = native_immediate_callbacks_tail_;
765
766
55005
  native_immediate_callbacks_tail_ = callback.get();
767


55005
  if (prev_tail != nullptr)
768
6280
    prev_tail->set_next(std::move(callback));
769
  else
770
48725
    native_immediate_callbacks_head_ = std::move(callback);
771
772
55005
  immediate_info()->count_inc(1);
773
55005
}
774
775
template <typename Fn>
776
32756
void Environment::SetImmediate(Fn&& cb, v8::Local<v8::Object> keep_alive) {
777
32756
  CreateImmediate(std::move(cb), keep_alive, true);
778
779


32756
  if (immediate_info()->ref_count() == 0)
780
23804
    ToggleImmediateRef(true);
781
32756
  immediate_info()->ref_count_inc(1);
782
32756
}
783
784
template <typename Fn>
785
22249
void Environment::SetUnrefImmediate(Fn&& cb, v8::Local<v8::Object> keep_alive) {
786
22249
  CreateImmediate(std::move(cb), keep_alive, false);
787
22249
}
788
789
55005
Environment::NativeImmediateCallback::NativeImmediateCallback(bool refed)
790
55005
  : refed_(refed) {}
791
792
54817
bool Environment::NativeImmediateCallback::is_refed() const {
793
54817
  return refed_;
794
}
795
796
std::unique_ptr<Environment::NativeImmediateCallback>
797
54816
Environment::NativeImmediateCallback::get_next() {
798
54816
  return std::move(next_);
799
}
800
801
6280
void Environment::NativeImmediateCallback::set_next(
802
    std::unique_ptr<NativeImmediateCallback> next) {
803
6280
  next_ = std::move(next);
804
6280
}
805
806
template <typename Fn>
807
55005
Environment::NativeImmediateCallbackImpl<Fn>::NativeImmediateCallbackImpl(
808
    Fn&& callback, v8::Global<v8::Object>&& keep_alive, bool refed)
809
  : NativeImmediateCallback(refed),
810
55005
    callback_(std::move(callback)),
811
165015
    keep_alive_(std::move(keep_alive)) {}
812
813
template <typename Fn>
814
54817
void Environment::NativeImmediateCallbackImpl<Fn>::Call(Environment* env) {
815
54817
  callback_(env);
816
54816
}
817
818
4121228
inline bool Environment::can_call_into_js() const {
819

4121228
  return can_call_into_js_ && !is_stopping();
820
}
821
822
4849
inline void Environment::set_can_call_into_js(bool can_call_into_js) {
823
4849
  can_call_into_js_ = can_call_into_js;
824
4849
}
825
826
21021
inline bool Environment::has_run_bootstrapping_code() const {
827
21021
  return has_run_bootstrapping_code_;
828
}
829
830
5193
inline void Environment::set_has_run_bootstrapping_code(bool value) {
831
5193
  has_run_bootstrapping_code_ = value;
832
5193
}
833
834
16
inline bool Environment::has_serialized_options() const {
835
16
  return has_serialized_options_;
836
}
837
838
5193
inline void Environment::set_has_serialized_options(bool value) {
839
5193
  has_serialized_options_ = value;
840
5193
}
841
842
25304
inline bool Environment::is_main_thread() const {
843
25304
  return flags_ & kIsMainThread;
844
}
845
846
30095
inline bool Environment::owns_process_state() const {
847
30095
  return flags_ & kOwnsProcessState;
848
}
849
850
5195
inline bool Environment::owns_inspector() const {
851
5195
  return flags_ & kOwnsInspector;
852
}
853
854
8810
inline uint64_t Environment::thread_id() const {
855
8810
  return thread_id_;
856
}
857
858
106
inline worker::Worker* Environment::worker_context() const {
859
106
  return worker_context_;
860
}
861
862
206
inline void Environment::set_worker_context(worker::Worker* context) {
863
206
  CHECK_NULL(worker_context_);  // Should be set only once.
864
206
  worker_context_ = context;
865
206
}
866
867
216
inline void Environment::add_sub_worker_context(worker::Worker* context) {
868
216
  sub_worker_contexts_.insert(context);
869
216
}
870
871
239
inline void Environment::remove_sub_worker_context(worker::Worker* context) {
872
239
  sub_worker_contexts_.erase(context);
873
239
}
874
875
4121054
inline bool Environment::is_stopping() const {
876
4121054
  return thread_stopper_.is_stopped();
877
}
878
879
40589
inline performance::performance_state* Environment::performance_state() {
880
40589
  return performance_state_.get();
881
}
882
883
inline std::unordered_map<std::string, uint64_t>*
884
43
    Environment::performance_marks() {
885
43
  return &performance_marks_;
886
}
887
888
6884736
inline IsolateData* Environment::isolate_data() const {
889
6884736
  return isolate_data_;
890
}
891
892
513895
inline char* Environment::AllocateUnchecked(size_t size) {
893
  return static_cast<char*>(
894
513895
      isolate_data()->allocator()->AllocateUninitialized(size));
895
}
896
897
493192
inline char* Environment::Allocate(size_t size) {
898
493192
  char* ret = AllocateUnchecked(size);
899
493192
  CHECK_NE(ret, nullptr);
900
493192
  return ret;
901
}
902
903
1290404
inline void Environment::Free(char* data, size_t size) {
904
1290404
  if (data != nullptr)
905
152943
    isolate_data()->allocator()->Free(data, size);
906
1290404
}
907
908
513895
inline AllocatedBuffer Environment::AllocateManaged(size_t size, bool checked) {
909
513895
  char* data = checked ? Allocate(size) : AllocateUnchecked(size);
910
513895
  if (data == nullptr) size = 0;
911
513895
  return AllocatedBuffer(this, uv_buf_init(data, size));
912
}
913
914
918626
inline AllocatedBuffer::AllocatedBuffer(Environment* env, uv_buf_t buf)
915
918626
    : env_(env), buffer_(buf) {}
916
917
353059
inline void AllocatedBuffer::Resize(size_t len) {
918
  // The `len` check is to make sure we don't end up with `nullptr` as our base.
919
  char* new_data = env_->Reallocate(buffer_.base, buffer_.len,
920
353059
                                    len > 0 ? len : 1);
921
353059
  CHECK_NOT_NULL(new_data);
922
353059
  buffer_ = uv_buf_init(new_data, len);
923
353059
}
924
925
2195351
inline uv_buf_t AllocatedBuffer::release() {
926
2195351
  uv_buf_t ret = buffer_;
927
2195351
  buffer_ = uv_buf_init(nullptr, 0);
928
2195351
  return ret;
929
}
930
931
829784
inline char* AllocatedBuffer::data() {
932
829784
  return buffer_.base;
933
}
934
935
inline const char* AllocatedBuffer::data() const {
936
  return buffer_.base;
937
}
938
939
874001
inline size_t AllocatedBuffer::size() const {
940
874001
  return buffer_.len;
941
}
942
943
167715
inline AllocatedBuffer::AllocatedBuffer(Environment* env)
944
167715
    : env_(env), buffer_(uv_buf_init(nullptr, 0)) {}
945
946
840
inline AllocatedBuffer::AllocatedBuffer(AllocatedBuffer&& other)
947
840
    : AllocatedBuffer() {
948
840
  *this = std::move(other);
949
840
}
950
951
174270
inline AllocatedBuffer& AllocatedBuffer::operator=(AllocatedBuffer&& other) {
952
174270
  clear();
953
174270
  env_ = other.env_;
954
174270
  buffer_ = other.release();
955
174270
  return *this;
956
}
957
958
1086185
inline AllocatedBuffer::~AllocatedBuffer() {
959
1086185
  clear();
960
1086185
}
961
962
1290404
inline void AllocatedBuffer::clear() {
963
1290404
  uv_buf_t buf = release();
964
1290404
  env_->Free(buf.base, buf.len);
965
1290404
}
966
967
// It's a bit awkward to define this Buffer::New() overload here, but it
968
// avoids a circular dependency with node_internals.h.
969
namespace Buffer {
970
v8::MaybeLocal<v8::Object> New(Environment* env,
971
                               char* data,
972
                               size_t length,
973
                               bool uses_malloc);
974
}
975
976
49609
inline v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
977
49609
  CHECK_NOT_NULL(env_);
978
49609
  v8::MaybeLocal<v8::Object> obj = Buffer::New(env_, data(), size(), false);
979
49609
  if (!obj.IsEmpty()) release();
980
49609
  return obj;
981
}
982
983
318976
inline v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
984
318976
  CHECK_NOT_NULL(env_);
985
318976
  uv_buf_t buf = release();
986
  return v8::ArrayBuffer::New(env_->isolate(),
987
                              buf.base,
988
                              buf.len,
989
318976
                              v8::ArrayBufferCreationMode::kInternalized);
990
}
991
992
697
inline void Environment::ThrowError(const char* errmsg) {
993
697
  ThrowError(v8::Exception::Error, errmsg);
994
697
}
995
996
2
inline void Environment::ThrowTypeError(const char* errmsg) {
997
2
  ThrowError(v8::Exception::TypeError, errmsg);
998
2
}
999
1000
inline void Environment::ThrowRangeError(const char* errmsg) {
1001
  ThrowError(v8::Exception::RangeError, errmsg);
1002
}
1003
1004
699
inline void Environment::ThrowError(
1005
    v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
1006
    const char* errmsg) {
1007
699
  v8::HandleScope handle_scope(isolate());
1008
699
  isolate()->ThrowException(fun(OneByteString(isolate(), errmsg)));
1009
699
}
1010
1011
3
inline void Environment::ThrowErrnoException(int errorno,
1012
                                             const char* syscall,
1013
                                             const char* message,
1014
                                             const char* path) {
1015
  isolate()->ThrowException(
1016
3
      ErrnoException(isolate(), errorno, syscall, message, path));
1017
3
}
1018
1019
13
inline void Environment::ThrowUVException(int errorno,
1020
                                          const char* syscall,
1021
                                          const char* message,
1022
                                          const char* path,
1023
                                          const char* dest) {
1024
  isolate()->ThrowException(
1025
13
      UVException(isolate(), errorno, syscall, message, path, dest));
1026
13
}
1027
1028
inline v8::Local<v8::FunctionTemplate>
1029
1921697
    Environment::NewFunctionTemplate(v8::FunctionCallback callback,
1030
                                     v8::Local<v8::Signature> signature,
1031
                                     v8::ConstructorBehavior behavior,
1032
                                     v8::SideEffectType side_effect_type) {
1033
1921697
  v8::Local<v8::Object> external = as_callback_data();
1034
  return v8::FunctionTemplate::New(isolate(), callback, external,
1035
1921691
                                   signature, 0, behavior, side_effect_type);
1036
}
1037
1038
788286
inline void Environment::SetMethod(v8::Local<v8::Object> that,
1039
                                   const char* name,
1040
                                   v8::FunctionCallback callback) {
1041
788286
  v8::Local<v8::Context> context = isolate()->GetCurrentContext();
1042
  v8::Local<v8::Function> function =
1043
      NewFunctionTemplate(callback, v8::Local<v8::Signature>(),
1044
                          v8::ConstructorBehavior::kThrow,
1045
788287
                          v8::SideEffectType::kHasSideEffect)
1046
2364865
          ->GetFunction(context)
1047
1576576
          .ToLocalChecked();
1048
  // kInternalized strings are created in the old space.
1049
788287
  const v8::NewStringType type = v8::NewStringType::kInternalized;
1050
  v8::Local<v8::String> name_string =
1051
1576576
      v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
1052
1576576
  that->Set(context, name_string, function).Check();
1053
788287
  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
1054
788288
}
1055
1056
345795
inline void Environment::SetMethodNoSideEffect(v8::Local<v8::Object> that,
1057
                                               const char* name,
1058
                                               v8::FunctionCallback callback) {
1059
345795
  v8::Local<v8::Context> context = isolate()->GetCurrentContext();
1060
  v8::Local<v8::Function> function =
1061
      NewFunctionTemplate(callback, v8::Local<v8::Signature>(),
1062
                          v8::ConstructorBehavior::kThrow,
1063
345809
                          v8::SideEffectType::kHasNoSideEffect)
1064
1037439
          ->GetFunction(context)
1065
691625
          .ToLocalChecked();
1066
  // kInternalized strings are created in the old space.
1067
345809
  const v8::NewStringType type = v8::NewStringType::kInternalized;
1068
  v8::Local<v8::String> name_string =
1069
691624
      v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
1070
691628
  that->Set(context, name_string, function).Check();
1071
345813
  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
1072
345815
}
1073
1074
536875
inline void Environment::SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
1075
                                        const char* name,
1076
                                        v8::FunctionCallback callback) {
1077
536875
  v8::Local<v8::Signature> signature = v8::Signature::New(isolate(), that);
1078
  v8::Local<v8::FunctionTemplate> t =
1079
      NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow,
1080
536876
                          v8::SideEffectType::kHasSideEffect);
1081
  // kInternalized strings are created in the old space.
1082
536876
  const v8::NewStringType type = v8::NewStringType::kInternalized;
1083
  v8::Local<v8::String> name_string =
1084
1073751
      v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
1085
1073750
  that->PrototypeTemplate()->Set(name_string, t);
1086
536875
  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
1087
536876
}
1088
1089
49207
inline void Environment::SetProtoMethodNoSideEffect(
1090
    v8::Local<v8::FunctionTemplate> that,
1091
    const char* name,
1092
    v8::FunctionCallback callback) {
1093
49207
  v8::Local<v8::Signature> signature = v8::Signature::New(isolate(), that);
1094
  v8::Local<v8::FunctionTemplate> t =
1095
      NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow,
1096
49207
                          v8::SideEffectType::kHasNoSideEffect);
1097
  // kInternalized strings are created in the old space.
1098
49207
  const v8::NewStringType type = v8::NewStringType::kInternalized;
1099
  v8::Local<v8::String> name_string =
1100
98414
      v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
1101
98414
  that->PrototypeTemplate()->Set(name_string, t);
1102
49207
  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
1103
49207
}
1104
1105
736560
void Environment::AddCleanupHook(void (*fn)(void*), void* arg) {
1106
  auto insertion_info = cleanup_hooks_.emplace(CleanupHookCallback {
1107
    fn, arg, cleanup_hook_counter_++
1108
736560
  });
1109
  // Make sure there was no existing element with these values.
1110
736561
  CHECK_EQ(insertion_info.second, true);
1111
736561
}
1112
1113
733805
void Environment::RemoveCleanupHook(void (*fn)(void*), void* arg) {
1114
733805
  CleanupHookCallback search { fn, arg, 0 };
1115
733805
  cleanup_hooks_.erase(search);
1116
733807
}
1117
1118
1608867
size_t CleanupHookCallback::Hash::operator()(
1119
    const CleanupHookCallback& cb) const {
1120
1608867
  return std::hash<void*>()(cb.arg_);
1121
}
1122
1123
802434
bool CleanupHookCallback::Equal::operator()(
1124
    const CleanupHookCallback& a, const CleanupHookCallback& b) const {
1125

802434
  return a.fn_ == b.fn_ && a.arg_ == b.arg_;
1126
}
1127
1128
349
BaseObject* CleanupHookCallback::GetBaseObject() const {
1129
349
  if (fn_ == BaseObject::DeleteMe)
1130
348
    return static_cast<BaseObject*>(arg_);
1131
  else
1132
1
    return nullptr;
1133
}
1134
1135
template <typename T>
1136
void Environment::ForEachBaseObject(T&& iterator) {
1137
  for (const auto& hook : cleanup_hooks_) {
1138
    BaseObject* obj = hook.GetBaseObject();
1139
    if (obj != nullptr)
1140
      iterator(obj);
1141
  }
1142
}
1143
1144
4121089
bool AsyncRequest::is_stopped() const {
1145
4121089
  return stopped_.load();
1146
}
1147
1148
5677
void AsyncRequest::set_stopped(bool flag) {
1149
5677
  stopped_.store(flag);
1150
5677
}
1151
1152
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
1153
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
1154
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
1155
#define V(TypeName, PropertyName)                                             \
1156
  inline                                                                      \
1157
  v8::Local<TypeName> IsolateData::PropertyName(v8::Isolate* isolate) const { \
1158
    /* Strings are immutable so casting away const-ness here is okay. */      \
1159
    return const_cast<IsolateData*>(this)->PropertyName ## _.Get(isolate);    \
1160
  }
1161
21146
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
1162
728768
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
1163
6487872
  PER_ISOLATE_STRING_PROPERTIES(VS)
1164
#undef V
1165
#undef VS
1166
#undef VY
1167
#undef VP
1168
1169
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
1170
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
1171
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
1172
#define V(TypeName, PropertyName)                                             \
1173
  inline v8::Local<TypeName> Environment::PropertyName() const {              \
1174
    return isolate_data()->PropertyName(isolate());                           \
1175
  }
1176
10573
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
1177
364080
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
1178
3233036
  PER_ISOLATE_STRING_PROPERTIES(VS)
1179
#undef V
1180
#undef VS
1181
#undef VY
1182
#undef VP
1183
1184
#define V(PropertyName, TypeName)                                             \
1185
  inline v8::Local<TypeName> Environment::PropertyName() const {              \
1186
    return PersistentToLocal::Strong(PropertyName ## _);                      \
1187
  }                                                                           \
1188
  inline void Environment::set_ ## PropertyName(v8::Local<TypeName> value) {  \
1189
    PropertyName ## _.Reset(isolate(), value);                                \
1190
  }
1191
549870
  ENVIRONMENT_STRONG_PERSISTENT_TEMPLATES(V)
1192
7907680
  ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
1193
#undef V
1194
1195
18555101
  inline v8::Local<v8::Context> Environment::context() const {
1196
18555101
    return PersistentToLocal::Strong(context_);
1197
  }
1198
}  // namespace node
1199
1200
#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
1201
1202
#endif  // SRC_ENV_INL_H_