blob: be07415db53825e456f6272784acae1bede54000 [file] [log] [blame]
// Copyright (c) 2021 Google LLC.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#include <queue>
#include <unordered_map>
#include <vector>
#include "source/opt/instruction.h"
#include "source/opt/ir_context.h"
namespace spvtools {
namespace opt {
// Generic data-flow analysis.
// Maintains a worklist of instructions to process and processes them in a
// specified order. See also ForwardDataFlowAnalysis, which is specialized for
// forward data-flow analysis.
class DataFlowAnalysis {
// The result of a |Visit| operation on an instruction.
// This is used to determine when analysis has reached a fixpoint.
enum class VisitResult {
// The analysis result for this instruction has changed.
// This means that any instructions that depend on it (its successors) must
// be recomputed.
// The analysis result for this instruction has not changed.
// When all visit operations return |kResultFixed|, the analysis has reached
// a fixpoint (converged).
virtual ~DataFlowAnalysis() {}
// Run this analysis on a given function.
// For analyses which work interprocedurally, |function| may be ignored.
void Run(Function* function);
DataFlowAnalysis(IRContext& context) : context_(context) {}
// Initialize the worklist for a given function.
// |is_first_iteration| is true on the first call to |Run| and false
// afterwards. All subsequent runs are only necessary to check if the analysis
// has converged; if |EnqueueSuccessors| is complete, |InitializeWorklist|
// should do nothing after the first iteration.
virtual void InitializeWorklist(Function* function,
bool is_first_iteration) = 0;
// Enqueues the successors (instructions which use the analysis result) of
// |inst|. This is not required to be complete, but convergence is faster when
// it is. This is called whenever |Visit| returns |kResultChanged|.
virtual void EnqueueSuccessors(Instruction* inst) = 0;
// Visits the given instruction, recomputing the analysis result. This is
// called once per instruction queued in |InitializeWorklist| and afterward
// when a predecessor is changed, through |EnqueueSuccessors|.
virtual VisitResult Visit(Instruction* inst) = 0;
// Enqueues the given instruction to be visited. Ignored if already in the
// worklist.
bool Enqueue(Instruction* inst);
IRContext& context() { return context_; }
// Runs one pass, calling |InitializeWorklist| and then iterating through the
// worklist until all fixed.
VisitResult RunOnce(Function* function, bool is_first_iteration);
IRContext& context_;
std::unordered_map<Instruction*, bool> on_worklist_;
// The worklist, which contains the list of instructions to be visited.
// The choice of data structure was influenced by the data in "Iterative
// Data-flow Analysis, Revisited" (Cooper et al, 2002).
// The paper shows that the overall performance benefit of a priority queue
// over a regular queue or stack is relatively small (or negative).
// A queue has the advantage that nodes are visited in the same order they are
// enqueued, which relieves the analysis from inserting nodes "backwards", for
// example in worklist initialization. Also, as the paper claims that sorting
// successors does not improve runtime, we can use a single queue which is
// modified during iteration.
std::queue<Instruction*> worklist_;
// A generic data flow analysis, specialized for forward analysis.
class ForwardDataFlowAnalysis : public DataFlowAnalysis {
// Indicates where labels should be in the worklist RPO ordering.
enum class LabelPosition {
// Labels should be placed at the beginning of their blocks.
// Labels should be placed at the end of their blocks.
// Labels should not be in the worklist.
// Only labels should be placed in the worklist.
ForwardDataFlowAnalysis(IRContext& context, LabelPosition label_position)
: DataFlowAnalysis(context), label_position_(label_position) {}
// Initializes the worklist in reverse postorder, regardless of
// |is_first_iteration|. Labels are placed according to the label position
// specified in the constructor.
void InitializeWorklist(Function* function, bool is_first_iteration) override;
// Enqueues the users and block successors of the given instruction.
// See |EnqueueUsers| and |EnqueueBlockSuccessors|.
void EnqueueSuccessors(Instruction* inst) override {
// Enqueues the users of the given instruction.
void EnqueueUsers(Instruction* inst);
// Enqueues the labels of the successors of the block corresponding to the
// given label instruction. Does nothing for other instructions.
void EnqueueBlockSuccessors(Instruction* inst);
LabelPosition label_position_;
} // namespace opt
} // namespace spvtools