mozjs_sys 0.67.1

System crate for the Mozilla SpiderMonkey JavaScript engine.
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

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef jit_CacheIRSpewer_h
#define jit_CacheIRSpewer_h

#ifdef JS_CACHEIR_SPEW

#  include "mozilla/Maybe.h"

#  include "jit/CacheIR.h"
#  include "js/TypeDecls.h"
#  include "threading/LockGuard.h"
#  include "vm/JSONPrinter.h"
#  include "vm/MutexIDs.h"

namespace js {
namespace jit {

class CacheIRSpewer {
  Mutex outputLock_;
  Fprinter output_;
  mozilla::Maybe<JSONPrinter> json_;
  static CacheIRSpewer cacheIRspewer;

  // Counter to record how many times Guard class is called. This is used to
  // determine when to flush outputs based on the given interval value.
  // For example, if |spewInterval_ = 2|, outputs will be flushed on
  // guardCount_ values 0,2,4,6,...
  uint32_t guardCount_;

  // Interval at which to flush output files. This value can be set with the
  // environment variable |CACHEIR_LOG_FLUSH|.
  uint32_t spewInterval_;

  CacheIRSpewer();
  ~CacheIRSpewer();

  bool enabled() { return json_.isSome(); }

  // These methods can only be called when enabled() is true.
  Mutex& lock() {
    MOZ_ASSERT(enabled());
    return outputLock_;
  }

  void beginCache(const IRGenerator& generator);
  void valueProperty(const char* name, const Value& v);
  void opcodeProperty(const char* name, const JSOp op);
  void cacheIRSequence(CacheIRReader& reader);
  void CacheIRArgs(JSONPrinter& j, CacheIRReader& r,
                   CacheIROpFormat::ArgType arg);
  template <typename... Args>
  void CacheIRArgs(JSONPrinter& j, CacheIRReader& r,
                   CacheIROpFormat::ArgType arg, Args... args);
  void attached(const char* name);
  void endCache();

 public:
  static CacheIRSpewer& singleton() { return cacheIRspewer; }
  bool init(const char* name);

  class MOZ_RAII Guard {
    CacheIRSpewer& sp_;
    const IRGenerator& gen_;
    const char* name_;

   public:
    Guard(const IRGenerator& gen, const char* name)
        : sp_(CacheIRSpewer::singleton()), gen_(gen), name_(name) {
      if (sp_.enabled()) {
        sp_.lock().lock();
        sp_.beginCache(gen_);
      }
    }

    ~Guard() {
      if (sp_.enabled()) {
        if (gen_.writerRef().codeLength() > 0) {
          CacheIRReader reader(gen_.writerRef());
          sp_.cacheIRSequence(reader);
        }
        if (name_ != nullptr) {
          sp_.attached(name_);
        }
        sp_.endCache();
        if (sp_.guardCount_++ % sp_.spewInterval_ == 0) {
          sp_.output_.flush();
        }
        sp_.lock().unlock();
      }
    }

    void valueProperty(const char* name, const Value& v) const {
      sp_.valueProperty(name, v);
    }

    void opcodeProperty(const char* name, const JSOp op) const {
      sp_.opcodeProperty(name, op);
    }

    explicit operator bool() const { return sp_.enabled(); }
  };
};

}  // namespace jit
}  // namespace js

#endif /* JS_CACHEIR_SPEW */

#endif /* jit_CacheIRSpewer_h */