| /* -*- 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_IonAnalysis_h |
| #define jit_IonAnalysis_h |
| |
| // This file declares various analysis passes that operate on MIR. |
| |
| #include "jit/JitAllocPolicy.h" |
| #include "jit/MIR.h" |
| |
| namespace js { |
| namespace jit { |
| |
| class MIRGenerator; |
| class MIRGraph; |
| |
| bool |
| PruneUnusedBranches(MIRGenerator* mir, MIRGraph& graph); |
| |
| bool |
| FoldTests(MIRGraph& graph); |
| |
| bool |
| SplitCriticalEdges(MIRGraph& graph); |
| |
| enum Observability { |
| ConservativeObservability, |
| AggressiveObservability |
| }; |
| |
| bool |
| EliminatePhis(MIRGenerator* mir, MIRGraph& graph, Observability observe); |
| |
| size_t |
| MarkLoopBlocks(MIRGraph& graph, MBasicBlock* header, bool* canOsr); |
| |
| void |
| UnmarkLoopBlocks(MIRGraph& graph, MBasicBlock* header); |
| |
| bool |
| MakeLoopsContiguous(MIRGraph& graph); |
| |
| bool |
| EliminateDeadResumePointOperands(MIRGenerator* mir, MIRGraph& graph); |
| |
| bool |
| EliminateDeadCode(MIRGenerator* mir, MIRGraph& graph); |
| |
| bool |
| ApplyTypeInformation(MIRGenerator* mir, MIRGraph& graph); |
| |
| bool |
| MakeMRegExpHoistable(MIRGraph& graph); |
| |
| bool |
| RenumberBlocks(MIRGraph& graph); |
| |
| bool |
| AccountForCFGChanges(MIRGenerator* mir, MIRGraph& graph, bool updateAliasAnalysis); |
| |
| bool |
| RemoveUnmarkedBlocks(MIRGenerator* mir, MIRGraph& graph, uint32_t numMarkedBlocks); |
| |
| void |
| ClearDominatorTree(MIRGraph& graph); |
| |
| bool |
| BuildDominatorTree(MIRGraph& graph); |
| |
| bool |
| BuildPhiReverseMapping(MIRGraph& graph); |
| |
| void |
| AssertBasicGraphCoherency(MIRGraph& graph); |
| |
| void |
| AssertGraphCoherency(MIRGraph& graph); |
| |
| void |
| AssertExtendedGraphCoherency(MIRGraph& graph); |
| |
| bool |
| EliminateRedundantChecks(MIRGraph& graph); |
| |
| void |
| AddKeepAliveInstructions(MIRGraph& graph); |
| |
| class MDefinition; |
| |
| // Simple linear sum of the form 'n' or 'x + n'. |
| struct SimpleLinearSum |
| { |
| MDefinition* term; |
| int32_t constant; |
| |
| SimpleLinearSum(MDefinition* term, int32_t constant) |
| : term(term), constant(constant) |
| {} |
| }; |
| |
| SimpleLinearSum |
| ExtractLinearSum(MDefinition* ins); |
| |
| bool |
| ExtractLinearInequality(MTest* test, BranchDirection direction, |
| SimpleLinearSum* plhs, MDefinition** prhs, bool* plessEqual); |
| |
| struct LinearTerm |
| { |
| MDefinition* term; |
| int32_t scale; |
| |
| LinearTerm(MDefinition* term, int32_t scale) |
| : term(term), scale(scale) |
| { |
| } |
| }; |
| |
| // General linear sum of the form 'x1*n1 + x2*n2 + ... + n' |
| class LinearSum |
| { |
| public: |
| explicit LinearSum(TempAllocator& alloc) |
| : terms_(alloc), |
| constant_(0) |
| { |
| } |
| |
| LinearSum(const LinearSum& other) |
| : terms_(other.terms_.allocPolicy()), |
| constant_(other.constant_) |
| { |
| AutoEnterOOMUnsafeRegion oomUnsafe; |
| if (!terms_.appendAll(other.terms_)) |
| oomUnsafe.crash("LinearSum::LinearSum"); |
| } |
| |
| // These return false on an integer overflow, and afterwards the sum must |
| // not be used. |
| bool multiply(int32_t scale); |
| bool add(const LinearSum& other, int32_t scale = 1); |
| bool add(SimpleLinearSum other, int32_t scale = 1); |
| bool add(MDefinition* term, int32_t scale); |
| bool add(int32_t constant); |
| |
| // Unlike the above function, on failure this leaves the sum unchanged and |
| // it can still be used. |
| bool divide(int32_t scale); |
| |
| int32_t constant() const { return constant_; } |
| size_t numTerms() const { return terms_.length(); } |
| LinearTerm term(size_t i) const { return terms_[i]; } |
| void replaceTerm(size_t i, MDefinition* def) { terms_[i].term = def; } |
| |
| void dump(GenericPrinter& out) const; |
| void dump() const; |
| |
| private: |
| Vector<LinearTerm, 2, JitAllocPolicy> terms_; |
| int32_t constant_; |
| }; |
| |
| // Convert all components of a linear sum (except, optionally, the constant) |
| // and add any new instructions to the end of block. |
| MDefinition* |
| ConvertLinearSum(TempAllocator& alloc, MBasicBlock* block, const LinearSum& sum, |
| bool convertConstant = false); |
| |
| // Convert the test 'sum >= 0' to a comparison, adding any necessary |
| // instructions to the end of block. |
| MCompare* |
| ConvertLinearInequality(TempAllocator& alloc, MBasicBlock* block, const LinearSum& sum); |
| |
| bool |
| AnalyzeNewScriptDefiniteProperties(JSContext* cx, JSFunction* fun, |
| ObjectGroup* group, HandlePlainObject baseobj, |
| Vector<TypeNewScript::Initializer>* initializerList); |
| |
| bool |
| AnalyzeArgumentsUsage(JSContext* cx, JSScript* script); |
| |
| bool |
| DeadIfUnused(const MDefinition* def); |
| |
| bool |
| IsDiscardable(const MDefinition* def); |
| |
| } // namespace jit |
| } // namespace js |
| |
| #endif /* jit_IonAnalysis_h */ |