tor-browser

IonOptimizationLevels.h (6670B)

---

/* -*- 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_IonOptimizationLevels_h
#define jit_IonOptimizationLevels_h

#include "mozilla/EnumeratedArray.h"

#include "jstypes.h"

#include "jit/JitOptions.h"
#include "js/TypeDecls.h"

namespace js {
namespace jit {

enum class OptimizationLevel : uint8_t { Normal, Wasm, Count, DontCompile };

#ifdef JS_JITSPEW
inline const char* OptimizationLevelString(OptimizationLevel level) {
 switch (level) {
   case OptimizationLevel::DontCompile:
     return "Optimization_DontCompile";
   case OptimizationLevel::Normal:
     return "Optimization_Normal";
   case OptimizationLevel::Wasm:
     return "Optimization_Wasm";
   case OptimizationLevel::Count:;
 }
 MOZ_CRASH("Invalid OptimizationLevel");
}
#endif

// Class representing the Ion optimization settings for an OptimizationLevel.
class OptimizationInfo {
 OptimizationLevel level_;

 // Toggles whether Effective Address Analysis is performed.
 bool eaa_;

 // Toggles whether Alignment Mask Analysis is performed.
 bool ama_;

 // Toggles whether Edge Case Analysis is used.
 bool edgeCaseAnalysis_;

 // Toggles whether redundant checks get removed.
 bool eliminateRedundantChecks_;

 // Toggles whether redundant shape guards get removed.
 bool eliminateRedundantShapeGuards_;

 // Toggles whether redundant GC barriers get removed.
 bool eliminateRedundantGCBarriers_;

 // 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 loop invariant code motion is performed.
 bool licm_;

 // Toggles whether Range Analysis is used.
 bool rangeAnalysis_;

 // Toggles whether instruction reordering is performed.
 bool reordering_;

 // Toggles whether Truncation based on Range Analysis is used.
 bool autoTruncate_;

 // Toggles whether sink is used.
 bool sink_;

 // Toggles whether scalar replacement is used.
 bool scalarReplacement_;

 // Describes which register allocator to use.
 IonRegisterAllocator registerAllocator_;

public:
 constexpr OptimizationInfo()
     : level_(OptimizationLevel::Normal),
       eaa_(false),
       ama_(false),
       edgeCaseAnalysis_(false),
       eliminateRedundantChecks_(false),
       eliminateRedundantShapeGuards_(false),
       eliminateRedundantGCBarriers_(false),
       inlineInterpreted_(false),
       inlineNative_(false),
       gvn_(false),
       licm_(false),
       rangeAnalysis_(false),
       reordering_(false),
       autoTruncate_(false),
       sink_(false),
       scalarReplacement_(false),
       registerAllocator_(RegisterAllocator_Backtracking) {}

 constexpr void initNormalOptimizationInfo() {
   level_ = OptimizationLevel::Normal;

   autoTruncate_ = true;
   eaa_ = true;
   edgeCaseAnalysis_ = true;
   eliminateRedundantChecks_ = true;
   eliminateRedundantShapeGuards_ = true;
   eliminateRedundantGCBarriers_ = true;
   inlineInterpreted_ = true;
   inlineNative_ = true;
   licm_ = true;
   gvn_ = true;
   rangeAnalysis_ = true;
   reordering_ = true;
   scalarReplacement_ = true;
   sink_ = true;

   registerAllocator_ = RegisterAllocator_Backtracking;
 }
 constexpr void initWasmOptimizationInfo() {
   // The Wasm optimization level
   // Disables some passes that don't work well with wasm.

   // Take normal option values for not specified values.
   initNormalOptimizationInfo();

   level_ = OptimizationLevel::Wasm;

   ama_ = true;
   autoTruncate_ = false;
   edgeCaseAnalysis_ = false;
   eliminateRedundantChecks_ = false;
   eliminateRedundantShapeGuards_ = false;
   eliminateRedundantGCBarriers_ = false;
   scalarReplacement_ = true;
   sink_ = false;
 }

 OptimizationLevel level() const { return level_; }

 bool inlineInterpreted() const {
   return inlineInterpreted_ && !JitOptions.disableInlining;
 }

 bool inlineNative() const {
   return inlineNative_ && !JitOptions.disableInlining;
 }

 static uint32_t baseWarmUpThresholdForScript(JSContext* cx, JSScript* script);
 static uint32_t warmUpThresholdForPC(JSScript* script, jsbytecode* pc,
                                      uint32_t baseThreshold);

 bool gvnEnabled() const { return gvn_ && !JitOptions.disableGvn; }

 bool licmEnabled() const { return licm_ && !JitOptions.disableLicm; }

 bool rangeAnalysisEnabled() const {
   return rangeAnalysis_ && !JitOptions.disableRangeAnalysis;
 }

 bool instructionReorderingEnabled() const {
   return reordering_ && !JitOptions.disableInstructionReordering;
 }

 bool autoTruncateEnabled() const {
   return autoTruncate_ && rangeAnalysisEnabled();
 }

 bool sinkEnabled() const { return sink_ && !JitOptions.disableSink; }

 bool eaaEnabled() const { return eaa_ && !JitOptions.disableEaa; }

 bool amaEnabled() const { return ama_ && !JitOptions.disableAma; }

 bool edgeCaseAnalysisEnabled() const {
   return edgeCaseAnalysis_ && !JitOptions.disableEdgeCaseAnalysis;
 }

 bool eliminateRedundantChecksEnabled() const {
   return eliminateRedundantChecks_;
 }

 bool eliminateRedundantShapeGuardsEnabled() const {
   return eliminateRedundantShapeGuards_ &&
          !JitOptions.disableRedundantShapeGuards;
 }

 bool eliminateRedundantGCBarriersEnabled() const {
   return eliminateRedundantGCBarriers_ &&
          !JitOptions.disableRedundantGCBarriers;
 }

 IonRegisterAllocator registerAllocator() const;

 bool scalarReplacementEnabled() const {
   return scalarReplacement_ && !JitOptions.disableScalarReplacement;
 }
};

class OptimizationLevelInfo {
private:
 mozilla::EnumeratedArray<OptimizationLevel, OptimizationInfo,
                          size_t(OptimizationLevel::Count)>
     infos_;

public:
 constexpr OptimizationLevelInfo() {
   infos_[OptimizationLevel::Normal].initNormalOptimizationInfo();
   infos_[OptimizationLevel::Wasm].initWasmOptimizationInfo();
 }

 const OptimizationInfo* get(OptimizationLevel level) const {
   return &infos_[level];
 }

 OptimizationLevel levelForScript(JSContext* cx, JSScript* script,
                                  jsbytecode* pc = nullptr) const;
};

constexpr OptimizationLevelInfo IonOptimizations;

}  // namespace jit
}  // namespace js

#endif /* jit_IonOptimizationLevels_h */