mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-25 04:50:04 +00:00
c2b2b57885
The front-end language compiler would simply emit DebugDeclare for
a variable when it is declared, which is effective through the variable's
scope. Since DebugDeclare only maps an OpVariable to a local variable,
the information can be removed when an optimization pass uses the
loaded value of the variable. DebugValue can be used to specify the
value of a variable. For each value update or phi instruction of a variable,
we can add DebugValue to help debugger inspect the variable at any
point of the program execution.
For example,
float a = 3;
... (complicated cfg) ...
foo(a); // <-- variable inspection: debugger can find DebugValue of `float a` in the nearest dominant
For the code with complicated CFG e.g., for-loop, if-statement, we
need help of ssa-rewrite to analyze the effective value of each variable
in each basic block.
If the value update of the variable happens only once and it dominates
all its uses, local-single-store-elim pass conducts the same value update
with ssa-rewrite and we have to let it add DebugValue for the value assignment.
One main issue is that we have to add DebugValue only when the value
update of a variable is visible to DebugDeclare. For example,
```
{ // scope1
%stack = OpVariable %ptr_int %int_3
{ // scope2
DebugDeclare %foo %stack <-- local variable "foo" in high-level language source code is declared as OpVariable "%stack"
// add DebugValue "foo = 3"
...
Store %stack %int_7 <-- foo = 7, add DebugValue "foo = 7"
...
// debugger can inspect the value of "foo"
}
Store %stack %int_11 <-- out of "scope2" i.e., scope of "foo". DO NOT add DebugValue "foo = 11"
}
```
However, the initalization of a variable is an exception.
For example, an argument passing of an inlined function must be done out of
the function's scope, but we must add a DebugValue for it.
```
// in HLSL
bar(float arg) { ... }
...
float foo = 3;
bar(foo);
// in SPIR-V
%arg = OpVariable
OpStore %arg %foo <-- Argument passing. Out of "float arg" scope, but we must add DebugValue for "float arg"
... body of function bar(float arg) ...
```
This PR handles the except case in local-single-store-elim pass. It adds
DebugValue for a store that is considered as an initialization.
The same exception handling code for ssa-rewrite is done by this commit: df4198e50e.
109 lines
3.8 KiB
C++
109 lines
3.8 KiB
C++
// Copyright (c) 2017 The Khronos Group Inc.
|
|
// Copyright (c) 2017 Valve Corporation
|
|
// Copyright (c) 2017 LunarG Inc.
|
|
//
|
|
// 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
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef SOURCE_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_
|
|
#define SOURCE_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_
|
|
|
|
#include <algorithm>
|
|
#include <map>
|
|
#include <queue>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "source/opt/basic_block.h"
|
|
#include "source/opt/def_use_manager.h"
|
|
#include "source/opt/mem_pass.h"
|
|
#include "source/opt/module.h"
|
|
|
|
namespace spvtools {
|
|
namespace opt {
|
|
|
|
// See optimizer.hpp for documentation.
|
|
class LocalSingleStoreElimPass : public Pass {
|
|
using cbb_ptr = const BasicBlock*;
|
|
|
|
public:
|
|
LocalSingleStoreElimPass();
|
|
|
|
const char* name() const override { return "eliminate-local-single-store"; }
|
|
Status Process() override;
|
|
|
|
IRContext::Analysis GetPreservedAnalyses() override {
|
|
return IRContext::kAnalysisDefUse |
|
|
IRContext::kAnalysisInstrToBlockMapping |
|
|
IRContext::kAnalysisConstants | IRContext::kAnalysisTypes;
|
|
}
|
|
|
|
private:
|
|
// Do "single-store" optimization of function variables defined only
|
|
// with a single non-access-chain store in |func|. Replace all their
|
|
// non-access-chain loads with the value that is stored and eliminate
|
|
// any resulting dead code.
|
|
bool LocalSingleStoreElim(Function* func);
|
|
|
|
// Initialize extensions allowlist
|
|
void InitExtensionAllowList();
|
|
|
|
// Return true if all extensions in this module are allowed by this pass.
|
|
bool AllExtensionsSupported() const;
|
|
|
|
Pass::Status ProcessImpl();
|
|
|
|
// If there is a single store to |var_inst|, and it covers the entire
|
|
// variable, then replace all of the loads of the entire variable that are
|
|
// dominated by the store by the value that was stored. Returns true if the
|
|
// module was changed.
|
|
bool ProcessVariable(Instruction* var_inst);
|
|
|
|
// Collects all of the uses of |var_inst| into |uses|. This looks through
|
|
// OpObjectCopy's that copy the address of the variable, and collects those
|
|
// uses as well.
|
|
void FindUses(const Instruction* var_inst,
|
|
std::vector<Instruction*>* uses) const;
|
|
|
|
// Returns a store to |var_inst| if
|
|
// - it is a store to the entire variable,
|
|
// - and there are no other instructions that may modify |var_inst|.
|
|
Instruction* FindSingleStoreAndCheckUses(
|
|
Instruction* var_inst, const std::vector<Instruction*>& users) const;
|
|
|
|
// Returns true if the address that results from |inst| may be used as a base
|
|
// address in a store instruction or may be used to compute the base address
|
|
// of a store instruction.
|
|
bool FeedsAStore(Instruction* inst) const;
|
|
|
|
// Replaces all of the loads in |uses| by the value stored in |store_inst|.
|
|
// The load instructions are then killed. |all_rewritten| is true iff all
|
|
// uses have been rewritten.
|
|
bool RewriteLoads(Instruction* store_inst,
|
|
const std::vector<Instruction*>& uses, bool* all_rewritten);
|
|
|
|
// Replaces DebugDeclares of |var_id| with DebugValues using the value
|
|
// assignment of |store_inst|.
|
|
bool RewriteDebugDeclares(Instruction* store_inst, uint32_t var_id);
|
|
|
|
// Extensions supported by this pass.
|
|
std::unordered_set<std::string> extensions_allowlist_;
|
|
};
|
|
|
|
} // namespace opt
|
|
} // namespace spvtools
|
|
|
|
#endif // SOURCE_OPT_LOCAL_SINGLE_STORE_ELIM_PASS_H_
|