The Tor Browser: comparison js/src/jit/IonOptimizationLevels.h

--1:000000000000
+:bbace0e81711
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+* vim: set ts=8 sts=4 et sw=4 tw=99:
+* 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_IonOptimizationLevels_h
+#define jit_IonOptimizationLevels_h
+#include "jsbytecode.h"
+#include "jstypes.h"
+#include "jit/JitOptions.h"
+#include "js/TypeDecls.h"
+namespace js {
+namespace jit {
+enum OptimizationLevel
+{
+Optimization_DontCompile,
+Optimization_Normal,
+Optimization_AsmJS,
+Optimization_Count
+};
+#ifdef JS_ION
+#ifdef DEBUG
+inline const char *
+OptimizationLevelString(OptimizationLevel level)
+{
+switch (level) {
+case Optimization_DontCompile:
+return "Optimization_DontCompile";
+case Optimization_Normal:
+return "Optimization_Normal";
+case Optimization_AsmJS:
+return "Optimization_AsmJS";
+default:
+MOZ_ASSUME_UNREACHABLE("Invalid OptimizationLevel");
+}
+}
+#endif
+class OptimizationInfo
+{
+public:
+OptimizationLevel level_;
+// Toggles whether Effective Address Analysis is performed.
+bool eaa_;
+// Toggles whether Edge Case Analysis is used.
+bool edgeCaseAnalysis_;
+// Toggles whether redundant checks get removed.
+bool eliminateRedundantChecks_;
+// Toggles whether interpreted scripts get inlined.
+bool inlineInterpreted_;
+// Toggles whether native scripts get inlined.
+bool inlineNative_;
+// Toggles whether global value numbering is used.
+bool gvn_;
+// Toggles whether global value numbering is optimistic or pessimistic.
+IonGvnKind gvnKind_;
+// Toggles whether loop invariant code motion is performed.
+bool licm_;
+// Toggles whether Unreachable Code Elimination is performed.
+bool uce_;
+// Toggles whether Range Analysis is used.
+bool rangeAnalysis_;
+// Describes which register allocator to use.
+IonRegisterAllocator registerAllocator_;
+// The maximum total bytecode size of an inline call site.
+uint32_t inlineMaxTotalBytecodeLength_;
+// The maximum bytecode length the caller may have,
+// before we stop inlining large functions in that caller.
+uint32_t inliningMaxCallerBytecodeLength_;
+// The maximum inlining depth.
+uint32_t maxInlineDepth_;
+// The maximum inlining depth for functions.
+//
+// Inlining small functions has almost no compiling overhead
+// and removes the otherwise needed call overhead.
+// The value is currently very low.
+// Actually it is only needed to make sure we don't blow out the stack.
+uint32_t smallFunctionMaxInlineDepth_;
+// How many invocations or loop iterations are needed before functions
+// are compiled.
+uint32_t usesBeforeCompile_;
+// How many invocations or loop iterations are needed before calls
+// are inlined, as a fraction of usesBeforeCompile.
+double usesBeforeInliningFactor_;
+OptimizationInfo()
+{ }
+void initNormalOptimizationInfo();
+void initAsmjsOptimizationInfo();
+OptimizationLevel level() const {
+return level_;
+}
+bool inlineInterpreted() const {
+return inlineInterpreted_ && !js_JitOptions.disableInlining;
+}
+bool inlineNative() const {
+return inlineNative_ && !js_JitOptions.disableInlining;
+}
+uint32_t usesBeforeCompile(JSScript *script, jsbytecode *pc = nullptr) const;
+bool gvnEnabled() const {
+return gvn_ && !js_JitOptions.disableGvn;
+}
+bool licmEnabled() const {
+return licm_ && !js_JitOptions.disableLicm;
+}
+bool uceEnabled() const {
+return uce_ && !js_JitOptions.disableUce;
+}
+bool rangeAnalysisEnabled() const {
+return rangeAnalysis_ && !js_JitOptions.disableRangeAnalysis;
+}
+bool eaaEnabled() const {
+return eaa_ && !js_JitOptions.disableEaa;
+}
+bool edgeCaseAnalysisEnabled() const {
+return edgeCaseAnalysis_ && !js_JitOptions.disableEdgeCaseAnalysis;
+}
+bool eliminateRedundantChecksEnabled() const {
+return eliminateRedundantChecks_;
+}
+IonGvnKind gvnKind() const {
+if (!js_JitOptions.forceGvnKind)
+return gvnKind_;
+return js_JitOptions.forcedGvnKind;
+}
+IonRegisterAllocator registerAllocator() const {
+if (!js_JitOptions.forceRegisterAllocator)
+return registerAllocator_;
+return js_JitOptions.forcedRegisterAllocator;
+}
+uint32_t smallFunctionMaxInlineDepth() const {
+return smallFunctionMaxInlineDepth_;
+}
+bool isSmallFunction(JSScript *script) const;
+uint32_t maxInlineDepth() const {
+return maxInlineDepth_;
+}
+uint32_t inlineMaxTotalBytecodeLength() const {
+return inlineMaxTotalBytecodeLength_;
+}
+uint32_t inliningMaxCallerBytecodeLength() const {
+return inlineMaxTotalBytecodeLength_;
+}
+uint32_t usesBeforeInlining() const {
+uint32_t usesBeforeCompile = usesBeforeCompile_;
+if (js_JitOptions.forceDefaultIonUsesBeforeCompile)
+usesBeforeCompile = js_JitOptions.forcedDefaultIonUsesBeforeCompile;
+return usesBeforeCompile * usesBeforeInliningFactor_;
+}
+};
+class OptimizationInfos
+{
+private:
+OptimizationInfo infos_[Optimization_Count - 1];
+public:
+OptimizationInfos();
+const OptimizationInfo *get(OptimizationLevel level) const {
+JS_ASSERT(level < Optimization_Count);
+JS_ASSERT(level != Optimization_DontCompile);
+return &infos_[level - 1];
+}
+OptimizationLevel nextLevel(OptimizationLevel level) const;
+OptimizationLevel firstLevel() const;
+bool isLastLevel(OptimizationLevel level) const;
+OptimizationLevel levelForScript(JSScript *script, jsbytecode *pc = nullptr) const;
+};
+extern OptimizationInfos js_IonOptimizations;
+#endif // JS_ION
+} // namespace jit
+} // namespace js
+#endif /* jit_IonOptimizationLevels_h */

The Tor Browser / file comparison

comparison: js/src/jit/IonOptimizationLevels.h

js/src/jit/IonOptimizationLevels.h