<div dir="ltr">Thanks for doing this!</div><br><div class="gmail_quote"><div dir="ltr" class="gmail_attr">On Tue, Jul 7, 2020 at 1:42 AM River Riddle <<a href="mailto:llvmlistbot@llvm.org">llvmlistbot@llvm.org</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><br>
Author: River Riddle<br>
Date: 2020-07-07T01:40:52-07:00<br>
New Revision: 9db53a182705ac1f652c6ee375735bea5539272c<br>
<br>
URL: <a href="https://github.com/llvm/llvm-project/commit/9db53a182705ac1f652c6ee375735bea5539272c" rel="noreferrer" target="_blank">https://github.com/llvm/llvm-project/commit/9db53a182705ac1f652c6ee375735bea5539272c</a><br>
DIFF: <a href="https://github.com/llvm/llvm-project/commit/9db53a182705ac1f652c6ee375735bea5539272c.diff" rel="noreferrer" target="_blank">https://github.com/llvm/llvm-project/commit/9db53a182705ac1f652c6ee375735bea5539272c.diff</a><br>
<br>
LOG: [mlir][NFC] Remove usernames and google bug numbers from TODO comments.<br>
<br>
These were largely leftover from when MLIR was a google project, and don't really follow LLVM guidelines.<br>
<br>
Added: <br>
<br>
<br>
Modified: <br>
mlir/docs/LangRef.md<br>
mlir/docs/OpDefinitions.md<br>
mlir/docs/Quantization.md<br>
mlir/docs/Rationale/Rationale.md<br>
mlir/include/mlir-c/Core.h<br>
mlir/include/mlir/Analysis/AffineAnalysis.h<br>
mlir/include/mlir/Analysis/AffineStructures.h<br>
mlir/include/mlir/Analysis/LoopAnalysis.h<br>
mlir/include/mlir/Analysis/NestedMatcher.h<br>
mlir/include/mlir/Analysis/Utils.h<br>
mlir/include/mlir/Dialect/AVX512/AVX512.td<br>
mlir/include/mlir/Dialect/Affine/IR/AffineOps.h<br>
mlir/include/mlir/Dialect/GPU/GPUBase.td<br>
mlir/include/mlir/Dialect/GPU/GPUOps.td<br>
mlir/include/mlir/Dialect/GPU/ParallelLoopMapper.h<br>
mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h<br>
mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td<br>
mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h<br>
mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td<br>
mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h<br>
mlir/include/mlir/Dialect/SPIRV/SPIRVMatrixOps.td<br>
mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td<br>
mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h<br>
mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td<br>
mlir/include/mlir/Dialect/StandardOps/EDSC/Builders.h<br>
mlir/include/mlir/Dialect/StandardOps/IR/Ops.h<br>
mlir/include/mlir/Dialect/Vector/VectorOps.td<br>
mlir/include/mlir/Dialect/Vector/VectorTransforms.h<br>
mlir/include/mlir/Dialect/Vector/VectorUtils.h<br>
mlir/include/mlir/IR/Attributes.h<br>
mlir/include/mlir/IR/Diagnostics.h<br>
mlir/include/mlir/IR/OpBase.td<br>
mlir/include/mlir/IR/StandardTypes.h<br>
mlir/include/mlir/Parser.h<br>
mlir/include/mlir/Pass/PassOptions.h<br>
mlir/include/mlir/TableGen/Operator.h<br>
mlir/include/mlir/TableGen/Pattern.h<br>
mlir/include/mlir/Transforms/DialectConversion.h<br>
mlir/include/mlir/Transforms/LoopFusionUtils.h<br>
mlir/include/mlir/Transforms/Utils.h<br>
mlir/lib/Analysis/AffineAnalysis.cpp<br>
mlir/lib/Analysis/AffineStructures.cpp<br>
mlir/lib/Analysis/LoopAnalysis.cpp<br>
mlir/lib/Analysis/NestedMatcher.cpp<br>
mlir/lib/Analysis/Utils.cpp<br>
mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp<br>
mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp<br>
mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp<br>
mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp<br>
mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp<br>
mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp<br>
mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp<br>
mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp<br>
mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp<br>
mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp<br>
mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp<br>
mlir/lib/Dialect/Affine/IR/AffineOps.cpp<br>
mlir/lib/Dialect/Affine/IR/AffineValueMap.cpp<br>
mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp<br>
mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp<br>
mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp<br>
mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp<br>
mlir/lib/Dialect/GPU/IR/GPUDialect.cpp<br>
mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp<br>
mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp<br>
mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp<br>
mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp<br>
mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp<br>
mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp<br>
mlir/lib/Dialect/Linalg/EDSC/Builders.cpp<br>
mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp<br>
mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp<br>
mlir/lib/Dialect/Linalg/Transforms/Loops.cpp<br>
mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp<br>
mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp<br>
mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp<br>
mlir/lib/Dialect/Linalg/Utils/Utils.cpp<br>
mlir/lib/Dialect/Quant/Utils/FakeQuantSupport.cpp<br>
mlir/lib/Dialect/Quant/Utils/QuantizeUtils.cpp<br>
mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp<br>
mlir/lib/Dialect/SDBM/SDBM.cpp<br>
mlir/lib/Dialect/SDBM/SDBMExpr.cpp<br>
mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp<br>
mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp<br>
mlir/lib/Dialect/SPIRV/SPIRVOps.cpp<br>
mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp<br>
mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp<br>
mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp<br>
mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp<br>
mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp<br>
mlir/lib/Dialect/StandardOps/IR/Ops.cpp<br>
mlir/lib/Dialect/Vector/VectorOps.cpp<br>
mlir/lib/Dialect/Vector/VectorTransforms.cpp<br>
mlir/lib/Dialect/Vector/VectorUtils.cpp<br>
mlir/lib/ExecutionEngine/ExecutionEngine.cpp<br>
mlir/lib/IR/AffineExpr.cpp<br>
mlir/lib/IR/AffineMap.cpp<br>
mlir/lib/IR/AsmPrinter.cpp<br>
mlir/lib/IR/AttributeDetail.h<br>
mlir/lib/IR/Operation.cpp<br>
mlir/lib/IR/StandardTypes.cpp<br>
mlir/lib/IR/Visitors.cpp<br>
mlir/lib/Parser/AttributeParser.cpp<br>
mlir/lib/Parser/DialectSymbolParser.cpp<br>
mlir/lib/Parser/Parser.cpp<br>
mlir/lib/Pass/PassRegistry.cpp<br>
mlir/lib/TableGen/OpClass.cpp<br>
mlir/lib/TableGen/Predicate.cpp<br>
mlir/lib/Target/LLVMIR/DebugTranslation.cpp<br>
mlir/lib/Target/LLVMIR/DebugTranslation.h<br>
mlir/lib/Target/LLVMIR/ModuleTranslation.cpp<br>
mlir/lib/Transforms/CSE.cpp<br>
mlir/lib/Transforms/DialectConversion.cpp<br>
mlir/lib/Transforms/Inliner.cpp<br>
mlir/lib/Transforms/LoopFusion.cpp<br>
mlir/lib/Transforms/MemRefDataFlowOpt.cpp<br>
mlir/lib/Transforms/PipelineDataTransfer.cpp<br>
mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp<br>
mlir/lib/Transforms/Utils/LoopFusionUtils.cpp<br>
mlir/lib/Transforms/Utils/LoopUtils.cpp<br>
mlir/lib/Transforms/Utils/Utils.cpp<br>
mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir<br>
mlir/test/Conversion/GPUToSPIRV/if.mlir<br>
mlir/test/Dialect/Linalg/roundtrip.mlir<br>
mlir/test/Dialect/SPIRV/Serialization/constant.mlir<br>
mlir/test/Dialect/SPIRV/canonicalize.mlir<br>
mlir/test/Dialect/SPIRV/structure-ops.mlir<br>
mlir/test/Dialect/SPIRV/types.mlir<br>
mlir/test/Dialect/Vector/vector-flat-transforms.mlir<br>
mlir/test/Dialect/Vector/vector-transforms.mlir<br>
mlir/test/IR/invalid-affinemap.mlir<br>
mlir/test/IR/invalid.mlir<br>
mlir/test/Transforms/loop-fusion.mlir<br>
mlir/test/Transforms/memref-dependence-check.mlir<br>
mlir/test/lib/DeclarativeTransforms/TestVectorTransformPatterns.td<br>
mlir/test/lib/Dialect/Test/TestPatterns.cpp<br>
mlir/test/lib/Transforms/TestInlining.cpp<br>
mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp<br>
mlir/test/lib/Transforms/TestMemRefDependenceCheck.cpp<br>
mlir/tools/mlir-rocm-runner/mlir-rocm-runner.cpp<br>
mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp<br>
mlir/tools/mlir-tblgen/OpDocGen.cpp<br>
mlir/tools/mlir-tblgen/OpFormatGen.cpp<br>
mlir/tools/mlir-tblgen/RewriterGen.cpp<br>
mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp<br>
mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp<br>
mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp<br>
mlir/utils/spirv/gen_spirv_dialect.py<br>
<br>
Removed: <br>
<br>
<br>
<br>
################################################################################<br>
diff --git a/mlir/docs/LangRef.md b/mlir/docs/LangRef.md<br>
index ff3af3e4e496..41b3984347bb 100644<br>
--- a/mlir/docs/LangRef.md<br>
+++ b/mlir/docs/LangRef.md<br>
@@ -148,7 +148,7 @@ integer-literal ::= decimal-literal | hexadecimal-literal<br>
decimal-literal ::= digit+<br>
hexadecimal-literal ::= `0x` hex_digit+<br>
float-literal ::= [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?<br>
-string-literal ::= `"` [^"\n\f\v\r]* `"` TODO define escaping rules<br>
+string-literal ::= `"` [^"\n\f\v\r]* `"` TODO: define escaping rules<br>
```<br>
<br>
Not listed here, but MLIR does support comments. They use standard BCPL syntax,<br>
<br>
diff --git a/mlir/docs/OpDefinitions.md b/mlir/docs/OpDefinitions.md<br>
index 025eaf616d73..a10610f87a0a 100644<br>
--- a/mlir/docs/OpDefinitions.md<br>
+++ b/mlir/docs/OpDefinitions.md<br>
@@ -964,9 +964,9 @@ is used. They serve as "hooks" to the enclosing environment. This includes<br>
replaced by the operand/result's type. E.g., for `F32` in `F32:$operand`, its<br>
`$_self` will be expanded as `getOperand(...).getType()`.<br>
<br>
-TODO(b/130663252): Reconsider the leading symbol for special placeholders.<br>
-Eventually we want to allow referencing operand/result $-names; such $-names<br>
-can start with underscore.<br>
+TODO: Reconsider the leading symbol for special placeholders. Eventually we want<br>
+to allow referencing operand/result $-names; such $-names can start with<br>
+underscore.<br>
<br>
For example, to write an attribute `attr` is an `IntegerAttr`, in C++ you can<br>
just call `attr.isa<IntegerAttr>()`. The code can be wrapped in a `CPred` as<br>
<br>
diff --git a/mlir/docs/Quantization.md b/mlir/docs/Quantization.md<br>
index 54eae406c87e..4abc52493cab 100644<br>
--- a/mlir/docs/Quantization.md<br>
+++ b/mlir/docs/Quantization.md<br>
@@ -196,7 +196,7 @@ operations for type conversion and expression of the supporting math.<br>
<br>
### Quantized type<br>
<br>
-TODO : Flesh this section out.<br>
+TODO: Flesh this section out.<br>
<br>
* QuantizedType base class<br>
* UniformQuantizedType<br>
@@ -247,7 +247,7 @@ in floating point with appropriate conversions at the boundaries.<br>
<br>
## TFLite native quantization<br>
<br>
-TODO : Flesh this out<br>
+TODO: Flesh this out<br>
<br>
### General algorithm<br>
<br>
<br>
diff --git a/mlir/docs/Rationale/Rationale.md b/mlir/docs/Rationale/Rationale.md<br>
index a3c3e5ecc4bf..22e21383e903 100644<br>
--- a/mlir/docs/Rationale/Rationale.md<br>
+++ b/mlir/docs/Rationale/Rationale.md<br>
@@ -765,7 +765,7 @@ func @conv2d(%input: memref<16x1024x1024x3xf32, #lm0, /*scratchpad=*/1>,<br>
}<br>
```<br>
<br>
-TODO (Add more examples showing the IR for a variety of interesting cases)<br>
+TODO: (Add more examples showing the IR for a variety of interesting cases)<br>
<br>
## Design alternatives and extensions<br>
<br>
<br>
diff --git a/mlir/include/mlir-c/Core.h b/mlir/include/mlir-c/Core.h<br>
index 4698a7feeb45..4c0666f56c28 100644<br>
--- a/mlir/include/mlir-c/Core.h<br>
+++ b/mlir/include/mlir-c/Core.h<br>
@@ -96,7 +96,7 @@ unsigned getFunctionArity(mlir_func_t function);<br>
/// Returns the rank of the `function` argument at position `pos`.<br>
/// If the argument is of MemRefType, this returns the rank of the MemRef.<br>
/// Otherwise returns `0`.<br>
-/// TODO(ntv): support more than MemRefType and scalar Type.<br>
+/// TODO: support more than MemRefType and scalar Type.<br>
unsigned getRankOfFunctionArgument(mlir_func_t function, unsigned pos);<br>
<br>
/// Returns an opaque mlir::Type of the `function` argument at position `pos`.<br>
<br>
diff --git a/mlir/include/mlir/Analysis/AffineAnalysis.h b/mlir/include/mlir/Analysis/AffineAnalysis.h<br>
index b421eee95148..3322f3da6a09 100644<br>
--- a/mlir/include/mlir/Analysis/AffineAnalysis.h<br>
+++ b/mlir/include/mlir/Analysis/AffineAnalysis.h<br>
@@ -38,7 +38,7 @@ void getReachableAffineApplyOps(ArrayRef<Value> operands,<br>
/// used to add appropriate inequalities. Any symbols founds in the bound<br>
/// operands are added as symbols in the system. Returns failure for the yet<br>
/// unimplemented cases.<br>
-// TODO(bondhugula): handle non-unit strides.<br>
+// TODO: handle non-unit strides.<br>
LogicalResult getIndexSet(MutableArrayRef<AffineForOp> forOps,<br>
FlatAffineConstraints *domain);<br>
<br>
@@ -49,8 +49,8 @@ struct MemRefAccess {<br>
SmallVector<Value, 4> indices;<br>
<br>
/// Constructs a MemRefAccess from a load or store operation.<br>
- // TODO(b/119949820): add accessors to standard op's load, store, DMA op's to<br>
- // return MemRefAccess, i.e., loadOp->getAccess(), dmaOp->getRead/WriteAccess.<br>
+ // TODO: add accessors to standard op's load, store, DMA op's to return<br>
+ // MemRefAccess, i.e., loadOp->getAccess(), dmaOp->getRead/WriteAccess.<br>
explicit MemRefAccess(Operation *opInst);<br>
<br>
// Returns the rank of the memref associated with this access.<br>
@@ -95,9 +95,9 @@ struct DependenceComponent {<br>
/// access the same memref element. If 'allowRAR' is true, will consider<br>
/// read-after-read dependences (typically used by applications trying to<br>
/// optimize input reuse).<br>
-// TODO(andydavis) Wrap 'dependenceConstraints' and 'dependenceComponents' into<br>
-// a single struct.<br>
-// TODO(andydavis) Make 'dependenceConstraints' optional arg.<br>
+// TODO: Wrap 'dependenceConstraints' and 'dependenceComponents' into a single<br>
+// struct.<br>
+// TODO: Make 'dependenceConstraints' optional arg.<br>
struct DependenceResult {<br>
enum ResultEnum {<br>
HasDependence, // A dependence exists between 'srcAccess' and 'dstAccess'.<br>
<br>
diff --git a/mlir/include/mlir/Analysis/AffineStructures.h b/mlir/include/mlir/Analysis/AffineStructures.h<br>
index 5858ab2ac62b..0424e0bb7d33 100644<br>
--- a/mlir/include/mlir/Analysis/AffineStructures.h<br>
+++ b/mlir/include/mlir/Analysis/AffineStructures.h<br>
@@ -98,7 +98,6 @@ class FlatAffineConstraints {<br>
<br>
/// Create a flat affine constraint system from an AffineValueMap or a list of<br>
/// these. The constructed system will only include equalities.<br>
- // TODO(bondhugula)<br>
explicit FlatAffineConstraints(const AffineValueMap &avm);<br>
explicit FlatAffineConstraints(ArrayRef<const AffineValueMap *> avmRef);<br>
<br>
@@ -213,7 +212,7 @@ class FlatAffineConstraints {<br>
/// 'affine.for' operation are added as trailing identifiers (either<br>
/// dimensional or symbolic depending on whether the operand is a valid<br>
/// symbol).<br>
- // TODO(bondhugula): add support for non-unit strides.<br>
+ // TODO: add support for non-unit strides.<br>
LogicalResult addAffineForOpDomain(AffineForOp forOp);<br>
<br>
/// Adds a lower or an upper bound for the identifier at the specified<br>
@@ -335,8 +334,8 @@ class FlatAffineConstraints {<br>
/// Projects out (aka eliminates) 'num' identifiers starting at position<br>
/// 'pos'. The resulting constraint system is the shadow along the dimensions<br>
/// that still exist. This method may not always be integer exact.<br>
- // TODO(bondhugula): deal with integer exactness when necessary - can return a<br>
- // value to mark exactness for example.<br>
+ // TODO: deal with integer exactness when necessary - can return a value to<br>
+ // mark exactness for example.<br>
void projectOut(unsigned pos, unsigned num);<br>
inline void projectOut(unsigned pos) { return projectOut(pos, 1); }<br>
<br>
<br>
diff --git a/mlir/include/mlir/Analysis/LoopAnalysis.h b/mlir/include/mlir/Analysis/LoopAnalysis.h<br>
index 7ed19ef99f87..b9c7d5e1b47a 100644<br>
--- a/mlir/include/mlir/Analysis/LoopAnalysis.h<br>
+++ b/mlir/include/mlir/Analysis/LoopAnalysis.h<br>
@@ -33,8 +33,8 @@ class Value;<br>
/// multi-result map. The trip count expression is simplified before returning.<br>
/// This method only utilizes map composition to construct lower and upper<br>
/// bounds before computing the trip count expressions<br>
-// TODO(mlir-team): this should be moved into 'Transforms/' and be replaced by a<br>
-// pure analysis method relying on FlatAffineConstraints<br>
+// TODO: this should be moved into 'Transforms/' and be replaced by a pure<br>
+// analysis method relying on FlatAffineConstraints<br>
void buildTripCountMapAndOperands(AffineForOp forOp, AffineMap *map,<br>
SmallVectorImpl<Value> *operands);<br>
<br>
@@ -65,7 +65,7 @@ using VectorizableLoopFun = std::function<bool(AffineForOp)>;<br>
/// Checks whether the loop is structurally vectorizable; i.e.:<br>
/// 1. no conditionals are nested under the loop;<br>
/// 2. all nested load/stores are to scalar MemRefs.<br>
-/// TODO(ntv): relax the no-conditionals restriction<br>
+/// TODO: relax the no-conditionals restriction<br>
bool isVectorizableLoopBody(AffineForOp loop,<br>
NestedPattern &vectorTransferMatcher);<br>
<br>
@@ -80,8 +80,8 @@ bool isVectorizableLoopBody(AffineForOp loop, int *memRefDim,<br>
/// Checks where SSA dominance would be violated if a for op's body<br>
/// operations are shifted by the specified shifts. This method checks if a<br>
/// 'def' and all its uses have the same shift factor.<br>
-// TODO(mlir-team): extend this to check for memory-based dependence<br>
-// violation when we have the support.<br>
+// TODO: extend this to check for memory-based dependence violation when we have<br>
+// the support.<br>
bool isOpwiseShiftValid(AffineForOp forOp, ArrayRef<uint64_t> shifts);<br>
} // end namespace mlir<br>
<br>
<br>
diff --git a/mlir/include/mlir/Analysis/NestedMatcher.h b/mlir/include/mlir/Analysis/NestedMatcher.h<br>
index 374fcab1bab5..594ea47e99e9 100644<br>
--- a/mlir/include/mlir/Analysis/NestedMatcher.h<br>
+++ b/mlir/include/mlir/Analysis/NestedMatcher.h<br>
@@ -73,7 +73,7 @@ class NestedMatch {<br>
/// 1. recursively matches a substructure in the tree;<br>
/// 2. uses a filter function to refine matches with extra semantic<br>
/// constraints (passed via a lambda of type FilterFunctionType);<br>
-/// 3. TODO(ntv) optionally applies actions (lambda).<br>
+/// 3. TODO: optionally applies actions (lambda).<br>
///<br>
/// Nested patterns are meant to capture imperfectly nested loops while matching<br>
/// properties over the whole loop nest. For instance, in vectorization we are<br>
<br>
diff --git a/mlir/include/mlir/Analysis/Utils.h b/mlir/include/mlir/Analysis/Utils.h<br>
index ce71e47c8e32..943a2f125b7d 100644<br>
--- a/mlir/include/mlir/Analysis/Utils.h<br>
+++ b/mlir/include/mlir/Analysis/Utils.h<br>
@@ -36,7 +36,7 @@ class Value;<br>
<br>
/// Populates 'loops' with IVs of the loops surrounding 'op' ordered from<br>
/// the outermost 'affine.for' operation to the innermost one.<br>
-// TODO(bondhugula): handle 'affine.if' ops.<br>
+// TODO: handle 'affine.if' ops.<br>
void getLoopIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops);<br>
<br>
/// Returns the nesting depth of this operation, i.e., the number of loops<br>
@@ -135,7 +135,7 @@ void getComputationSliceState(Operation *depSourceOp, Operation *depSinkOp,<br>
/// surrounding ops in 'opsB', as a function of IVs and symbols of loop nest<br>
/// surrounding ops in 'opsA' at 'loopDepth'.<br>
/// Returns 'success' if union was computed, 'failure' otherwise.<br>
-// TODO(andydavis) Change this API to take 'forOpA'/'forOpB'.<br>
+// TODO: Change this API to take 'forOpA'/'forOpB'.<br>
LogicalResult computeSliceUnion(ArrayRef<Operation *> opsA,<br>
ArrayRef<Operation *> opsB, unsigned loopDepth,<br>
unsigned numCommonLoops, bool isBackwardSlice,<br>
@@ -150,7 +150,7 @@ LogicalResult computeSliceUnion(ArrayRef<Operation *> opsA,<br>
// Loop depth is a crucial optimization choice that determines where to<br>
// materialize the results of the backward slice - presenting a trade-off b/w<br>
// storage and redundant computation in several cases.<br>
-// TODO(andydavis) Support computation slices with common surrounding loops.<br>
+// TODO: Support computation slices with common surrounding loops.<br>
AffineForOp insertBackwardComputationSlice(Operation *srcOpInst,<br>
Operation *dstOpInst,<br>
unsigned dstLoopDepth,<br>
@@ -271,7 +271,7 @@ struct MemRefRegion {<br>
/// identifiers since getMemRefRegion() is called with a specific loop depth,<br>
/// and thus the region is symbolic in the outer surrounding loops at that<br>
/// depth.<br>
- // TODO(bondhugula): Replace this to exploit HyperRectangularSet.<br>
+ // TODO: Replace this to exploit HyperRectangularSet.<br>
FlatAffineConstraints cst;<br>
};<br>
<br>
<br>
diff --git a/mlir/include/mlir/Dialect/AVX512/AVX512.td b/mlir/include/mlir/Dialect/AVX512/AVX512.td<br>
index 82d24ef13d68..e1ed35c50e87 100644<br>
--- a/mlir/include/mlir/Dialect/AVX512/AVX512.td<br>
+++ b/mlir/include/mlir/Dialect/AVX512/AVX512.td<br>
@@ -55,7 +55,7 @@ def MaskRndScaleOp : AVX512_Op<"mask.rndscale", [NoSideEffect,<br>
I32:$k,<br>
VectorOfLengthAndType<[16, 8], [F32, F64]>:$a,<br>
AnyTypeOf<[I16, I8]>:$imm,<br>
- // TODO(ntv): figure rounding out (optional operand?).<br>
+ // TODO: figure rounding out (optional operand?).<br>
I32:$rounding<br>
);<br>
let results = (outs VectorOfLengthAndType<[16, 8], [F32, F64]>:$dst);<br>
@@ -87,7 +87,7 @@ def MaskScaleFOp : AVX512_Op<"mask.scalef", [NoSideEffect,<br>
VectorOfLengthAndType<[16, 8], [F32, F64]>:$a,<br>
VectorOfLengthAndType<[16, 8], [F32, F64]>:$b,<br>
AnyTypeOf<[I16, I8]>:$k,<br>
- // TODO(ntv): figure rounding out (optional operand?).<br>
+ // TODO: figure rounding out (optional operand?).<br>
I32:$rounding<br>
);<br>
let results = (outs VectorOfLengthAndType<[16, 8], [F32, F64]>:$dst);<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.h b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.h<br>
index 93bac5a4a29f..8498a45c1147 100644<br>
--- a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.h<br>
+++ b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.h<br>
@@ -75,10 +75,10 @@ bool isTopLevelValue(Value value);<br>
// affine.dma_start %src[%i, %j], %dst[%k, %l], %tag[%idx], %num_elements,<br>
// %stride, %num_elt_per_stride : ...<br>
//<br>
-// TODO(mlir-team): add additional operands to allow source and destination<br>
-// striding, and multiple stride levels (possibly using AffineMaps to specify<br>
-// multiple levels of striding).<br>
-// TODO(andydavis) Consider replacing src/dst memref indices with view memrefs.<br>
+// TODO: add additional operands to allow source and destination striding, and<br>
+// multiple stride levels (possibly using AffineMaps to specify multiple levels<br>
+// of striding).<br>
+// TODO: Consider replacing src/dst memref indices with view memrefs.<br>
class AffineDmaStartOp : public Op<AffineDmaStartOp, OpTrait::VariadicOperands,<br>
OpTrait::ZeroResult> {<br>
public:<br>
<br>
diff --git a/mlir/include/mlir/Dialect/GPU/GPUBase.td b/mlir/include/mlir/Dialect/GPU/GPUBase.td<br>
index 16ce93fb1ed9..32e0952a15b4 100644<br>
--- a/mlir/include/mlir/Dialect/GPU/GPUBase.td<br>
+++ b/mlir/include/mlir/Dialect/GPU/GPUBase.td<br>
@@ -39,7 +39,7 @@ def GPU_Dialect : Dialect {<br>
<br>
/// Returns the number of workgroup (thread, block) dimensions supported in<br>
/// the GPU dialect.<br>
- // TODO(zinenko,herhut): consider generalizing this.<br>
+ // TODO: consider generalizing this.<br>
static unsigned getNumWorkgroupDimensions() { return 3; }<br>
<br>
/// Returns the numeric value used to identify the workgroup memory address<br>
<br>
diff --git a/mlir/include/mlir/Dialect/GPU/GPUOps.td b/mlir/include/mlir/Dialect/GPU/GPUOps.td<br>
index 281696d0eb98..e7e67e24381d 100644<br>
--- a/mlir/include/mlir/Dialect/GPU/GPUOps.td<br>
+++ b/mlir/include/mlir/Dialect/GPU/GPUOps.td<br>
@@ -224,8 +224,7 @@ def GPU_GPUFuncOp : GPU_Op<"func", [HasParent<"GPUModuleOp">,<br>
/// - the argument/result attributes may need an update: if the new type<br>
/// has less parameters we drop the extra attributes, if there are more<br>
/// parameters they won't have any attributes.<br>
- // TODO(b/146349912): consider removing this function thanks to rewrite<br>
- // patterns.<br>
+ // TODO: consider removing this function thanks to rewrite patterns.<br>
void setType(FunctionType newType);<br>
<br>
/// Returns the number of buffers located in the workgroup memory.<br>
<br>
diff --git a/mlir/include/mlir/Dialect/GPU/ParallelLoopMapper.h b/mlir/include/mlir/Dialect/GPU/ParallelLoopMapper.h<br>
index 842734d256d3..298ec0c803f0 100644<br>
--- a/mlir/include/mlir/Dialect/GPU/ParallelLoopMapper.h<br>
+++ b/mlir/include/mlir/Dialect/GPU/ParallelLoopMapper.h<br>
@@ -44,7 +44,7 @@ inline Processor getProcessor(ParallelLoopDimMapping attr) {<br>
}<br>
<br>
/// Helper function to create a ParallelDimMapperAttr.<br>
-/// TODO(ravishankarm/antiagainst): Replace its uses with an auto-gened method.<br>
+/// TODO: Replace its uses with an auto-gened method.<br>
ParallelLoopDimMapping getParallelLoopDimMappingAttr(Processor processor,<br>
AffineMap map,<br>
AffineMap bound);<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h b/mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h<br>
index 15f89a8ec5e0..5b6cb0ac7fa4 100644<br>
--- a/mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h<br>
+++ b/mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h<br>
@@ -67,7 +67,7 @@ void mulRegionBuilder(ValueRange args);<br>
/// the current ScopedContext, at the current insert point.<br>
void macRegionBuilder(ValueRange args);<br>
<br>
-/// TODO(ntv): In the future we should tie these implementations to something in<br>
+/// TODO: In the future we should tie these implementations to something in<br>
/// Tablegen that generates the proper interfaces and the proper sugared named<br>
/// ops.<br>
<br>
@@ -119,7 +119,7 @@ Operation *linalg_generic_pointwise_max(StructuredIndexed I1,<br>
StructuredIndexed I2,<br>
StructuredIndexed O);<br>
<br>
-// TODO(ntv): Implement more useful pointwise operations on a per-need basis.<br>
+// TODO: Implement more useful pointwise operations on a per-need basis.<br>
<br>
using MatmulRegionBuilder = function_ref<void(ValueRange args)>;<br>
<br>
@@ -187,7 +187,7 @@ linalg_generic_matmul(Container values,<br>
///<br>
/// For now `...` must be empty (i.e. only 2-D convolutions are supported).<br>
///<br>
-// TODO(ntv) Extend convolution rank with some template magic.<br>
+// TODO: Extend convolution rank with some template magic.<br>
Operation *linalg_generic_conv_nhwc(Value vI, Value vW, Value vO,<br>
ArrayRef<int> strides = {},<br>
ArrayRef<int> dilations = {});<br>
@@ -222,7 +222,7 @@ Operation *linalg_generic_conv_nhwc(Container values,<br>
///<br>
/// For now `...` must be empty (i.e. only 2-D convolutions are supported).<br>
///<br>
-// TODO(ntv) Extend convolution rank with some template magic.<br>
+// TODO: Extend convolution rank with some template magic.<br>
Operation *linalg_generic_dilated_conv_nhwc(Value vI, Value vW, Value vO,<br>
int depth_multiplier = 1,<br>
ArrayRef<int> strides = {},<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td<br>
index 4dd652168eb6..9cda61ca80b7 100644<br>
--- a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td<br>
+++ b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td<br>
@@ -119,8 +119,8 @@ def CopyOp : LinalgStructured_Op<"copy", [<br>
OptionalAttr<AffineMapAttr>:$inputPermutation,<br>
OptionalAttr<AffineMapAttr>:$outputPermutation);<br>
<br>
- // TODO(ntv) this should go away once the usage of OptionalAttr triggers<br>
- // emission of builders with default arguments left unspecified.<br>
+ // TODO: this should go away once the usage of OptionalAttr triggers emission<br>
+ // of builders with default arguments left unspecified.<br>
let builders = [OpBuilder<<br>
"OpBuilder &builder, OperationState &result, Value input, Value output", [{<br>
return build(<br>
@@ -305,8 +305,8 @@ def ConvOp : PoolingBase_Op<"conv", [NInputs<2>, NOutputs<1>]> {<br>
OptionalAttr<I64ElementsAttr>:$padding);<br>
<br>
let extraClassDeclaration = commonUtils # [{<br>
- // TODO(ntv) extend to support more than 1 dimensions and potentially<br>
- // grouping too.<br>
+ // TODO: extend to support more than 1 dimensions and potentially grouping<br>
+ // too.<br>
unsigned getNumBatchDimensions() { return 1; }<br>
<br>
unsigned getNumInputFeatureDimensions() { return 1; }<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h b/mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h<br>
index 4ab547be2019..8dda7d0a1445 100644<br>
--- a/mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h<br>
+++ b/mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h<br>
@@ -246,8 +246,8 @@ class StructuredOpTraits<br>
cast<ConcreteType>(this->getOperation()).referenceIterators();<br>
<br>
// If there is no reference, this must be a generic op.<br>
- // TODO(ntv): Traits are used to define ops. Split into cpp to avoid<br>
- // cyclic dependency.<br>
+ // TODO: Traits are used to define ops. Split into cpp to avoid cyclic<br>
+ // dependency.<br>
auto name = this->getOperation()->getName().getStringRef();<br>
if (!maybeReferenceIteratorTypes && name != "generic" &&<br>
name != "indexed_generic") {<br>
@@ -263,8 +263,8 @@ class StructuredOpTraits<br>
return StringAttr::get(str, ctx);<br>
});<br>
auto attr = ArrayAttr::get(llvm::to_vector<4>(attrRange), ctx);<br>
- // TODO(ntv): Need to memoize this. Can't just store as an attribute atm as<br>
- // it will impact parser, printer and tests.<br>
+ // TODO: Need to memoize this. Can't just store as an attribute atm as it<br>
+ // will impact parser, printer and tests.<br>
// this->getOperation()->setAttr("iterator_types", attr);<br>
return attr;<br>
}<br>
@@ -301,8 +301,8 @@ class StructuredOpTraits<br>
});<br>
SmallVector<Attribute, 4> attrs{attrRange.begin(), attrRange.end()};<br>
auto attr = ArrayAttr::get(attrs, ctx);<br>
- // TODO(ntv): Need to memoize this. Can't just store as an attribute atm as<br>
- // it will impact parser, printer and tests.<br>
+ // TODO: Need to memoize this. Can't just store as an attribute atm as it<br>
+ // will impact parser, printer and tests.<br>
// this->getOperation()->setAttr("indexing_maps", attr);<br>
return attr;<br>
}<br>
<br>
diff --git a/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td b/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td<br>
index 832171e92336..fab1f63f7f30 100644<br>
--- a/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td<br>
+++ b/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td<br>
@@ -162,7 +162,7 @@ class Extension<list<StrEnumAttrCase> extensions> : Availability {<br>
AND (`Extension::C`) AND (`Extension::D` OR `Extension::E`) is enabled.<br>
}];<br>
<br>
- // TODO(antiagainst): Returning SmallVector<ArrayRef<...>> is not recommended.<br>
+ // TODO: Returning SmallVector<ArrayRef<...>> is not recommended.<br>
// Find a better way for this.<br>
let queryFnRetType = "::llvm::SmallVector<::llvm::ArrayRef<"<br>
"::mlir::spirv::Extension>, 1>";<br>
@@ -226,9 +226,8 @@ class Capability<list<I32EnumAttrCase> capabilities> : Availability {<br>
let instance = "ref";<br>
}<br>
<br>
-// TODO(antiagainst): the following interfaces definitions are duplicating with<br>
-// the above. Remove them once we are able to support dialect-specific contents<br>
-// in ODS.<br>
+// TODO: the following interfaces definitions are duplicating with the above.<br>
+// Remove them once we are able to support dialect-specific contents in ODS.<br>
def QueryMinVersionInterface : OpInterface<"QueryMinVersionInterface"> {<br>
let methods = [InterfaceMethod<"", "::mlir::spirv::Version", "getMinVersion">];<br>
}<br>
@@ -3061,7 +3060,7 @@ def SPV_IntVec4 : SPV_Vec4<SPV_Integer>;<br>
def SPV_IOrUIVec4 : SPV_Vec4<SPV_SignlessOrUnsignedInt>;<br>
def SPV_Int32Vec4 : SPV_Vec4<AnyI32>;<br>
<br>
-// TODO(ravishankarm): From 1.4, this should also include Composite type.<br>
+// TODO: From 1.4, this should also include Composite type.<br>
def SPV_SelectType : AnyTypeOf<[SPV_Scalar, SPV_Vector, SPV_AnyPtr]>;<br>
<br>
//===----------------------------------------------------------------------===//<br>
@@ -3317,9 +3316,9 @@ def SPV_OpcodeAttr :<br>
// Base class for all SPIR-V ops.<br>
class SPV_Op<string mnemonic, list<OpTrait> traits = []> :<br>
Op<SPIRV_Dialect, mnemonic, !listconcat(traits, [<br>
- // TODO(antiagainst): We don't need all of the following traits for<br>
- // every op; only the suitable ones should be added automatically<br>
- // after ODS supports dialect-specific contents.<br>
+ // TODO: We don't need all of the following traits for every op; only<br>
+ // the suitable ones should be added automatically after ODS supports<br>
+ // dialect-specific contents.<br>
DeclareOpInterfaceMethods<QueryMinVersionInterface>,<br>
DeclareOpInterfaceMethods<QueryMaxVersionInterface>,<br>
DeclareOpInterfaceMethods<QueryExtensionInterface>,<br>
<br>
diff --git a/mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h b/mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h<br>
index f0a429941fb3..02a1f0861da8 100644<br>
--- a/mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h<br>
+++ b/mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h<br>
@@ -35,8 +35,8 @@ namespace mlir {<br>
/// satisfy shader interface requirements: shader interface types must be<br>
/// pointers to structs.<br>
///<br>
-/// TODO(antiagainst): We might want to introduce a way to control how<br>
-/// unsupported bitwidth are handled and explicitly fail if wanted.<br>
+/// TODO: We might want to introduce a way to control how unsupported bitwidth<br>
+/// are handled and explicitly fail if wanted.<br>
class SPIRVTypeConverter : public TypeConverter {<br>
public:<br>
explicit SPIRVTypeConverter(spirv::TargetEnvAttr targetAttr);<br>
@@ -120,8 +120,8 @@ Value getBuiltinVariableValue(Operation *op, BuiltIn builtin,<br>
/// Performs the index computation to get to the element at `indices` of the<br>
/// memory pointed to by `basePtr`, using the layout map of `baseType`.<br>
<br>
-// TODO(ravishankarm) : This method assumes that the `baseType` is a MemRefType<br>
-// with AffineMap that has static strides. Extend to handle dynamic strides.<br>
+// TODO: This method assumes that the `baseType` is a MemRefType with AffineMap<br>
+// that has static strides. Extend to handle dynamic strides.<br>
spirv::AccessChainOp getElementPtr(SPIRVTypeConverter &typeConverter,<br>
MemRefType baseType, Value basePtr,<br>
ValueRange indices, Location loc,<br>
<br>
diff --git a/mlir/include/mlir/Dialect/SPIRV/SPIRVMatrixOps.td b/mlir/include/mlir/Dialect/SPIRV/SPIRVMatrixOps.td<br>
index 07d7fd1093c2..8545c7ad29e2 100644<br>
--- a/mlir/include/mlir/Dialect/SPIRV/SPIRVMatrixOps.td<br>
+++ b/mlir/include/mlir/Dialect/SPIRV/SPIRVMatrixOps.td<br>
@@ -61,8 +61,8 @@ def SPV_MatrixTimesScalarOp : SPV_Op<"MatrixTimesScalar", []> {<br>
SPV_AnyMatrix:$result<br>
);<br>
<br>
- // TODO (Hazem): we need just one matrix type given that the input and result<br>
- // are the same and the scalar's type can be deduced from it.<br>
+ // TODO: we need just one matrix type given that the input and result are the<br>
+ // same and the scalar's type can be deduced from it.<br>
let assemblyFormat = [{<br>
operands attr-dict `:` type($matrix) `,` type($scalar) `->` type($result)<br>
}];<br>
@@ -133,4 +133,4 @@ def SPV_TransposeOp : SPV_Op<"Transpose", []> {<br>
<br>
// -----<br>
<br>
-#endif // SPIRV_MATRIX_OPS<br>
\ No newline at end of file<br>
+#endif // SPIRV_MATRIX_OPS<br>
<br>
diff --git a/mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td b/mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td<br>
index 0c4cad17f8de..034b7d1b09c7 100644<br>
--- a/mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td<br>
+++ b/mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td<br>
@@ -102,7 +102,7 @@ def SPV_ConstantOp : SPV_Op<"constant", [ConstantLike, NoSideEffect]> {<br>
%2 = spv.constant [dense<3.0> : vector<2xf32>] : !spv.array<1xvector<2xf32>><br>
```<br>
<br>
- TODO(antiagainst): support constant structs<br>
+ TODO: support constant structs<br>
}];<br>
<br>
let arguments = (ins<br>
@@ -541,7 +541,7 @@ def SPV_SpecConstantOp : SPV_Op<"specConstant", [InModuleScope, Symbol]> {<br>
spv.specConstant @spec_const2 spec_id(5) = 42 : i32<br>
```<br>
<br>
- TODO(antiagainst): support composite spec constants with another op<br>
+ TODO: support composite spec constants with another op<br>
}];<br>
<br>
let arguments = (ins<br>
<br>
diff --git a/mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h b/mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h<br>
index 95855785e31b..d2dac563bfcf 100644<br>
--- a/mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h<br>
+++ b/mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h<br>
@@ -216,7 +216,7 @@ class ImageType<br>
ImageSamplingInfo getSamplingInfo() const;<br>
ImageSamplerUseInfo getSamplerUseInfo() const;<br>
ImageFormat getImageFormat() const;<br>
- // TODO(ravishankarm): Add support for Access qualifier<br>
+ // TODO: Add support for Access qualifier<br>
<br>
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,<br>
Optional<spirv::StorageClass> storage = llvm::None);<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td b/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td<br>
index 1fb88a791b70..6f263cd6db63 100644<br>
--- a/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td<br>
+++ b/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td<br>
@@ -479,7 +479,7 @@ def Shape_ConcatOp : Shape_Op<"concat", []> {<br>
// Shape constraint related ops.<br>
//===----------------------------------------------------------------------===//<br>
<br>
-//TODO(tpopp): Move the code below and witnesses to a <br>
diff erent file.<br>
+// TODO: Move the code below and witnesses to a <br>
diff erent file.<br>
def Shape_AnyOp : Shape_Op<"any", [Commutative, NoSideEffect]> {<br>
let summary = "Return any combination of the input shapes";<br>
let description = [{<br>
<br>
diff --git a/mlir/include/mlir/Dialect/StandardOps/EDSC/Builders.h b/mlir/include/mlir/Dialect/StandardOps/EDSC/Builders.h<br>
index 5f0d6d83df99..36df24f60c70 100644<br>
--- a/mlir/include/mlir/Dialect/StandardOps/EDSC/Builders.h<br>
+++ b/mlir/include/mlir/Dialect/StandardOps/EDSC/Builders.h<br>
@@ -48,7 +48,7 @@ class BoundsCapture {<br>
/// MemRef. It has placeholders for non-contiguous tensors that fit within the<br>
/// Fortran subarray model.<br>
/// At the moment it can only capture a MemRef with an identity layout map.<br>
-// TODO(ntv): Support MemRefs with layoutMaps.<br>
+// TODO: Support MemRefs with layoutMaps.<br>
class MemRefBoundsCapture : public BoundsCapture {<br>
public:<br>
explicit MemRefBoundsCapture(Value v);<br>
<br>
diff --git a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h<br>
index 7599988bdefc..0f24d74dcac2 100644<br>
--- a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h<br>
+++ b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.h<br>
@@ -129,9 +129,9 @@ class ConstantIndexOp : public ConstantOp {<br>
// dma_start %src[%i, %j], %dst[%k, %l], %num_elements, %tag[%idx], %stride,<br>
// %num_elt_per_stride :<br>
//<br>
-// TODO(mlir-team): add additional operands to allow source and destination<br>
-// striding, and multiple stride levels.<br>
-// TODO(andydavis) Consider replacing src/dst memref indices with view memrefs.<br>
+// TODO: add additional operands to allow source and destination striding, and<br>
+// multiple stride levels.<br>
+// TODO: Consider replacing src/dst memref indices with view memrefs.<br>
class DmaStartOp<br>
: public Op<DmaStartOp, OpTrait::VariadicOperands, OpTrait::ZeroResult> {<br>
public:<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Vector/VectorOps.td b/mlir/include/mlir/Dialect/Vector/VectorOps.td<br>
index 8ca9baf2e0d0..a02f39f943f8 100644<br>
--- a/mlir/include/mlir/Dialect/Vector/VectorOps.td<br>
+++ b/mlir/include/mlir/Dialect/Vector/VectorOps.td<br>
@@ -37,8 +37,8 @@ class Vector_Op<string mnemonic, list<OpTrait> traits = []> :<br>
let parser = [{ return ::parse$cppClass(parser, result); }];<br>
}<br>
<br>
-// TODO(andydavis, ntv) Add an attribute to specify a <br>
diff erent algebra<br>
-// with operators other than the current set: {*, +}.<br>
+// TODO: Add an attribute to specify a <br>
diff erent algebra with operators other<br>
+// than the current set: {*, +}.<br>
def Vector_ContractionOp :<br>
Vector_Op<"contract", [<br>
NoSideEffect,<br>
@@ -714,8 +714,8 @@ def Vector_OuterProductOp :<br>
}];<br>
}<br>
<br>
-// TODO(andydavis) Add transformation which decomposes ReshapeOp into an<br>
-// optimized sequence of vector rotate/shuffle/select operations.<br>
+// TODO: Add transformation which decomposes ReshapeOp into an optimized<br>
+// sequence of vector rotate/shuffle/select operations.<br>
def Vector_ReshapeOp :<br>
Vector_Op<"reshape", [AttrSizedOperandSegments, NoSideEffect]>,<br>
Arguments<(ins AnyVector:$vector, Variadic<Index>:$input_shape,<br>
@@ -849,7 +849,7 @@ def Vector_ExtractStridedSliceOp :<br>
attribute and extracts the n-D subvector at the proper offset.<br>
<br>
At the moment strides must contain only 1s.<br>
- // TODO(ntv) support non-1 strides.<br>
+ // TODO: support non-1 strides.<br>
<br>
Returns an n-D vector where the first k-D dimensions match the `sizes`<br>
attribute. The returned subvector contains the elements starting at offset<br>
@@ -862,7 +862,7 @@ def Vector_ExtractStridedSliceOp :<br>
{offsets = [0, 2], sizes = [2, 4], strides = [1, 1]}:<br>
vector<4x8x16xf32> to vector<2x4x16xf32><br>
<br>
- // TODO(ntv) Evolve to a range form syntax similar to:<br>
+ // TODO: Evolve to a range form syntax similar to:<br>
%1 = vector.extract_strided_slice %0[0:2:1][2:4:1]<br>
vector<4x8x16xf32> to vector<2x4x16xf32><br>
```<br>
@@ -1513,7 +1513,7 @@ def Vector_MatmulOp : Vector_Op<"matrix_multiply", [NoSideEffect,<br>
PredOpTrait<"rhs operand and result have same element type",<br>
TCresVTEtIsSameAsOpBase<0, 1>>]>,<br>
Arguments<(<br>
- // TODO(ntv, fhahn): tighten vector element types that make sense.<br>
+ // TODO: tighten vector element types that make sense.<br>
ins VectorOfRankAndType<[1],<br>
[AnySignlessInteger, AnySignedInteger, AnyFloat]>:$lhs,<br>
VectorOfRankAndType<[1],<br>
@@ -1576,7 +1576,7 @@ def Vector_FlatTransposeOp : Vector_Op<"flat_transpose", [NoSideEffect,<br>
PredOpTrait<"source operand and result have same element type",<br>
TCresVTEtIsSameAsOpBase<0, 0>>]>,<br>
Arguments<(<br>
- // TODO(ntv, fhahn, ajcbik): tighten vector element types that make sense.<br>
+ // TODO: tighten vector element types that make sense.<br>
ins VectorOfRankAndType<[1],<br>
[AnySignlessInteger, AnySignedInteger, AnyFloat]>:$matrix,<br>
I32Attr:$rows, I32Attr:$columns)>,<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Vector/VectorTransforms.h b/mlir/include/mlir/Dialect/Vector/VectorTransforms.h<br>
index ab69a8246587..ca67be9512f7 100644<br>
--- a/mlir/include/mlir/Dialect/Vector/VectorTransforms.h<br>
+++ b/mlir/include/mlir/Dialect/Vector/VectorTransforms.h<br>
@@ -183,8 +183,8 @@ class ContractionOpToOuterProductOpLowering<br>
///<br>
/// This only kicks in when VectorTransformsOptions is set to AXPY.<br>
//<br>
-// TODO (ajcbik): this is very similar, but not quite the same as<br>
-// the outerproduct lowering above; merge the two?<br>
+// TODO: this is very similar, but not quite the same as the outerproduct<br>
+// lowering above; merge the two?<br>
class ContractionOpToAXPYLowering<br>
: public OpRewritePattern<vector::ContractionOp> {<br>
public:<br>
<br>
diff --git a/mlir/include/mlir/Dialect/Vector/VectorUtils.h b/mlir/include/mlir/Dialect/Vector/VectorUtils.h<br>
index 58f936ca305c..19f7f9538307 100644<br>
--- a/mlir/include/mlir/Dialect/Vector/VectorUtils.h<br>
+++ b/mlir/include/mlir/Dialect/Vector/VectorUtils.h<br>
@@ -160,9 +160,9 @@ namespace matcher {<br>
/// over other smaller vector types in the function and avoids interfering with<br>
/// operations on those.<br>
/// This is a first approximation, it can easily be extended in the future.<br>
-/// TODO(ntv): this could all be much simpler if we added a bit that a vector<br>
-/// type to mark that a vector is a strict super-vector but it still does not<br>
-/// warrant adding even 1 extra bit in the IR for now.<br>
+/// TODO: this could all be much simpler if we added a bit that a vector type to<br>
+/// mark that a vector is a strict super-vector but it still does not warrant<br>
+/// adding even 1 extra bit in the IR for now.<br>
bool operatesOnSuperVectorsOf(Operation &op, VectorType subVectorType);<br>
<br>
} // end namespace matcher<br>
<br>
diff --git a/mlir/include/mlir/IR/Attributes.h b/mlir/include/mlir/IR/Attributes.h<br>
index f01937fd9794..6436bb9550e8 100644<br>
--- a/mlir/include/mlir/IR/Attributes.h<br>
+++ b/mlir/include/mlir/IR/Attributes.h<br>
@@ -417,7 +417,7 @@ class IntegerAttr<br>
APInt getValue() const;<br>
/// Return the integer value as a 64-bit int. The attribute must be a signless<br>
/// integer.<br>
- // TODO(jpienaar): Change callers to use getValue instead.<br>
+ // TODO: Change callers to use getValue instead.<br>
int64_t getInt() const;<br>
/// Return the integer value as a signed 64-bit int. The attribute must be<br>
/// a signed integer.<br>
@@ -1438,8 +1438,7 @@ class SparseElementsAttr<br>
auto zeroValue = getZeroValue<T>();<br>
auto valueIt = getValues().getValues<T>().begin();<br>
const std::vector<ptr<br>
diff _t> flatSparseIndices(getFlattenedSparseIndices());<br>
- // TODO(riverriddle): Move-capture flatSparseIndices when c++14 is<br>
- // available.<br>
+ // TODO: Move-capture flatSparseIndices when c++14 is available.<br>
std::function<T(ptr<br>
diff _t)> mapFn = [=](ptr<br>
diff _t index) {<br>
// Try to map the current index to one of the sparse indices.<br>
for (unsigned i = 0, e = flatSparseIndices.size(); i != e; ++i)<br>
<br>
diff --git a/mlir/include/mlir/IR/Diagnostics.h b/mlir/include/mlir/IR/Diagnostics.h<br>
index 584ff4b1e242..84411b720336 100644<br>
--- a/mlir/include/mlir/IR/Diagnostics.h<br>
+++ b/mlir/include/mlir/IR/Diagnostics.h<br>
@@ -558,7 +558,7 @@ class SourceMgrDiagnosticHandler : public ScopedDiagnosticHandler {<br>
llvm::SMLoc convertLocToSMLoc(FileLineColLoc loc);<br>
<br>
/// The maximum depth that a call stack will be printed.<br>
- /// TODO(riverriddle) This should be a tunable flag.<br>
+ /// TODO: This should be a tunable flag.<br>
unsigned callStackLimit = 10;<br>
<br>
std::unique_ptr<detail::SourceMgrDiagnosticHandlerImpl> impl;<br>
<br>
diff --git a/mlir/include/mlir/IR/OpBase.td b/mlir/include/mlir/IR/OpBase.td<br>
index e6fba75ea971..4344d075bc34 100644<br>
--- a/mlir/include/mlir/IR/OpBase.td<br>
+++ b/mlir/include/mlir/IR/OpBase.td<br>
@@ -144,7 +144,7 @@ class Concat<string pre, Pred child, string suf> :<br>
// Constraint definitions<br>
//===----------------------------------------------------------------------===//<br>
<br>
-// TODO(b/130064155): Merge Constraints into Pred.<br>
+// TODO: Merge Constraints into Pred.<br>
<br>
// Base class for named constraints.<br>
//<br>
@@ -314,8 +314,8 @@ class Optional<Type type> : TypeConstraint<type.predicate, type.description> {<br>
// Note that this does not "inherit" from Type because it would require<br>
// duplicating Type subclasses for buildable and non-buildable cases to avoid<br>
// diamond "inheritance".<br>
-// TODO(zinenko): we may extend this to a more general 'Buildable' trait,<br>
-// making some Types and some Attrs buildable.<br>
+// TODO: we may extend this to a more general 'Buildable' trait, making some<br>
+// Types and some Attrs buildable.<br>
class BuildableType<code builder> {<br>
// The builder call to invoke (if specified) to construct the BuildableType.<br>
code builderCall = builder;<br>
@@ -578,7 +578,7 @@ def AnyRankedTensor :<br>
ShapedContainerType<[AnyType], And<[IsTensorTypePred, HasRankPred]>,<br>
"ranked tensor">;<br>
<br>
-// TODO(b/130064155) Have an easy way to add another constraint to a type.<br>
+// TODO: Have an easy way to add another constraint to a type.<br>
class StaticShapeTensorOf<list<Type> allowedTypes><br>
: Type<And<[TensorOf<allowedTypes>.predicate, HasStaticShapePred]>,<br>
"statically shaped " # TensorOf<allowedTypes>.description>;<br>
@@ -636,7 +636,7 @@ def F16MemRef : MemRefOf<[F16]>;<br>
def F32MemRef : MemRefOf<[F32]>;<br>
def F64MemRef : MemRefOf<[F64]>;<br>
<br>
-// TODO(b/130064155) Have an easy way to add another constraint to a type.<br>
+// TODO: Have an easy way to add another constraint to a type.<br>
class MemRefRankOf<list<Type> allowedTypes, list<int> ranks> :<br>
Type<And<[MemRefOf<allowedTypes>.predicate, HasAnyRankOfPred<ranks>]>,<br>
StrJoin<!foreach(rank, ranks, rank # "D"), "/">.result # " " #<br>
@@ -1083,7 +1083,7 @@ class EnumAttrInfo<string name, list<EnumAttrCaseInfo> cases> {<br>
// use "::" as the delimiter, e.g., given "A::B", generated code will be<br>
// placed in `namespace A { namespace B { ... } }`. To avoid placing in any<br>
// namespace, use "".<br>
- // TODO(b/134741431): use dialect to provide the namespace.<br>
+ // TODO: use dialect to provide the namespace.<br>
string cppNamespace = "";<br>
<br>
// The name of the utility function that converts a value of the underlying<br>
@@ -1585,7 +1585,7 @@ def IsNullAttr : AttrConstraint<<br>
// An attribute constraint on FlatSymbolRefAttr that requires that the<br>
// reference point to an op of `opClass` within the closest parent with a symbol<br>
// table.<br>
-// TODO(riverriddle) Add support for nested symbol references.<br>
+// TODO: Add support for nested symbol references.<br>
class ReferToOp<string opClass> : AttrConstraint<<br>
CPred<"isa_and_nonnull<" # opClass # ">("<br>
"::mlir::SymbolTable::lookupNearestSymbolFrom("<br>
@@ -1711,8 +1711,8 @@ class ParentOneOf<list<string> ops><br>
def FirstAttrDerivedResultType :<br>
GenInternalOpTrait<"FirstAttrDerivedResultType">;<br>
<br>
-// TODO(antiagainst): Turn the following into normal traits and generate<br>
-// verification for them.<br>
+// TODO: Turn the following into normal traits and generate verification for<br>
+// them.<br>
<br>
// All variadic operands of the op have the same number of values.<br>
// A variadic operand contains an array of values whose array size is only<br>
@@ -1980,9 +1980,9 @@ class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {<br>
code verifier = ?;<br>
<br>
// Whether this op has associated canonicalization patterns.<br>
- // TODO(b/120163349): figure out a better way to write canonicalization<br>
- // patterns in TableGen rules directly instead of using this marker<br>
- // and C++ implementations.<br>
+ // TODO: figure out a better way to write canonicalization patterns in<br>
+ // TableGen rules directly instead of using this marker and C++<br>
+ // implementations.<br>
bit hasCanonicalizer = 0;<br>
<br>
// Whether this op has a folder.<br>
@@ -2024,7 +2024,7 @@ def HasNoUseOf: Constraint<<br>
<br>
// These traits often require including "mlir/IR/TypeUtilities.h".<br>
<br>
-// TODO(b/135033717): Improve the autogenerated error messages.<br>
+// TODO: Improve the autogenerated error messages.<br>
<br>
class Rank<string name> :<br>
StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>().getRank()">;<br>
@@ -2045,7 +2045,7 @@ class AllMatchPred<list<string> values> :<br>
class AllMatch<list<string> values, string description> :<br>
PredOpTrait<description, AllMatchPred<values>>;<br>
<br>
-// TODO(b/135032064): Only works for non-variadic.<br>
+// TODO: Only works for non-variadic.<br>
class AllMatchSameOperatorPred<list<string> names, string operator> :<br>
AllMatchPred<!foreach(n, names, !subst("$_self", "$" # n, operator))>;<br>
<br>
<br>
diff --git a/mlir/include/mlir/IR/StandardTypes.h b/mlir/include/mlir/IR/StandardTypes.h<br>
index 85ac33bcf1ff..5380668b5901 100644<br>
--- a/mlir/include/mlir/IR/StandardTypes.h<br>
+++ b/mlir/include/mlir/IR/StandardTypes.h<br>
@@ -250,7 +250,7 @@ class ShapedType : public Type {<br>
using ImplType = detail::ShapedTypeStorage;<br>
using Type::Type;<br>
<br>
- // TODO(ntv): merge these two special values in a single one used everywhere.<br>
+ // TODO: merge these two special values in a single one used everywhere.<br>
// Unfortunately, uses of `-1` have crept deep into the codebase now and are<br>
// hard to track.<br>
static constexpr int64_t kDynamicSize = -1;<br>
@@ -561,7 +561,7 @@ class MemRefType : public Type::TypeBase<MemRefType, BaseMemRefType,<br>
/// Returns the memory space in which data referred to by this memref resides.<br>
unsigned getMemorySpace() const;<br>
<br>
- // TODO(ntv): merge these two special values in a single one used everywhere.<br>
+ // TODO: merge these two special values in a single one used everywhere.<br>
// Unfortunately, uses of `-1` have crept deep into the codebase now and are<br>
// hard to track.<br>
static constexpr int64_t kDynamicSize = -1;<br>
<br>
diff --git a/mlir/include/mlir/Parser.h b/mlir/include/mlir/Parser.h<br>
index 40bd4f83d345..8bba2ef4d53d 100644<br>
--- a/mlir/include/mlir/Parser.h<br>
+++ b/mlir/include/mlir/Parser.h<br>
@@ -58,7 +58,7 @@ OwningModuleRef parseSourceString(llvm::StringRef moduleStr,<br>
/// constructed from a new SourceMgr with a single a MemoryBuffer wrapping<br>
/// `attrStr`. If the passed `attrStr` has additional tokens that were not part<br>
/// of the type, an error is emitted.<br>
-// TODO(ntv) Improve diagnostic reporting.<br>
+// TODO: Improve diagnostic reporting.<br>
Attribute parseAttribute(llvm::StringRef attrStr, MLIRContext *context);<br>
Attribute parseAttribute(llvm::StringRef attrStr, Type type);<br>
<br>
@@ -76,7 +76,7 @@ Attribute parseAttribute(llvm::StringRef attrStr, Type type, size_t &numRead);<br>
/// constructed from a new SourceMgr with a single a MemoryBuffer wrapping<br>
/// `typeStr`. If the passed `typeStr` has additional tokens that were not part<br>
/// of the type, an error is emitted.<br>
-// TODO(ntv) Improve diagnostic reporting.<br>
+// TODO: Improve diagnostic reporting.<br>
Type parseType(llvm::StringRef typeStr, MLIRContext *context);<br>
<br>
/// This parses a single MLIR type to an MLIR context if it was valid. If not,<br>
<br>
diff --git a/mlir/include/mlir/Pass/PassOptions.h b/mlir/include/mlir/Pass/PassOptions.h<br>
index de4795a385f0..04754196e67a 100644<br>
--- a/mlir/include/mlir/Pass/PassOptions.h<br>
+++ b/mlir/include/mlir/Pass/PassOptions.h<br>
@@ -96,8 +96,8 @@ class PassOptions : protected llvm::cl::SubCommand {<br>
/// The specific parser to use depending on llvm::cl parser used. This is only<br>
/// necessary because we need to provide additional methods for certain data<br>
/// type parsers.<br>
- /// TODO(riverriddle) We should upstream the methods in GenericOptionParser to<br>
- /// avoid the need to do this.<br>
+ /// TODO: We should upstream the methods in GenericOptionParser to avoid the<br>
+ /// need to do this.<br>
template <typename DataType><br>
using OptionParser =<br>
std::conditional_t<std::is_base_of<llvm::cl::generic_parser_base,<br>
<br>
diff --git a/mlir/include/mlir/TableGen/Operator.h b/mlir/include/mlir/TableGen/Operator.h<br>
index 8f567a7615af..29d4caa32467 100644<br>
--- a/mlir/include/mlir/TableGen/Operator.h<br>
+++ b/mlir/include/mlir/TableGen/Operator.h<br>
@@ -219,9 +219,9 @@ class Operator {<br>
StringRef getExtraClassDeclaration() const;<br>
<br>
// Returns the Tablegen definition this operator was constructed from.<br>
- // TODO(antiagainst,zinenko): do not expose the TableGen record, this is a<br>
- // temporary solution to OpEmitter requiring a Record because Operator does<br>
- // not provide enough methods.<br>
+ // TODO: do not expose the TableGen record, this is a temporary solution to<br>
+ // OpEmitter requiring a Record because Operator does not provide enough<br>
+ // methods.<br>
const llvm::Record &getDef() const;<br>
<br>
// Returns the dialect of the op.<br>
<br>
diff --git a/mlir/include/mlir/TableGen/Pattern.h b/mlir/include/mlir/TableGen/Pattern.h<br>
index 94b9cde9332a..a5759e358f69 100644<br>
--- a/mlir/include/mlir/TableGen/Pattern.h<br>
+++ b/mlir/include/mlir/TableGen/Pattern.h<br>
@@ -407,8 +407,8 @@ class Pattern {<br>
const llvm::Record &def;<br>
<br>
// All operators.<br>
- // TODO(antiagainst): we need a proper context manager, like MLIRContext,<br>
- // for managing the lifetime of shared entities.<br>
+ // TODO: we need a proper context manager, like MLIRContext, for managing the<br>
+ // lifetime of shared entities.<br>
RecordOperatorMap *recordOpMap;<br>
};<br>
<br>
<br>
diff --git a/mlir/include/mlir/Transforms/DialectConversion.h b/mlir/include/mlir/Transforms/DialectConversion.h<br>
index d862823930c5..26b7ce6ea6c3 100644<br>
--- a/mlir/include/mlir/Transforms/DialectConversion.h<br>
+++ b/mlir/include/mlir/Transforms/DialectConversion.h<br>
@@ -355,8 +355,7 @@ struct OpConversionPattern : public ConversionPattern {<br>
return matchAndRewrite(cast<SourceOp>(op), operands, rewriter);<br>
}<br>
<br>
- // TODO(b/142763075): Use OperandAdaptor when it supports access to unnamed<br>
- // operands.<br>
+ // TODO: Use OperandAdaptor when it supports access to unnamed operands.<br>
<br>
/// Rewrite and Match methods that operate on the SourceOp type. These must be<br>
/// overridden by the derived pattern class.<br>
<br>
diff --git a/mlir/include/mlir/Transforms/LoopFusionUtils.h b/mlir/include/mlir/Transforms/LoopFusionUtils.h<br>
index 2832f050fc55..36d2520b7c85 100644<br>
--- a/mlir/include/mlir/Transforms/LoopFusionUtils.h<br>
+++ b/mlir/include/mlir/Transforms/LoopFusionUtils.h<br>
@@ -24,9 +24,8 @@ class AffineForOp;<br>
struct ComputationSliceState;<br>
class Operation;<br>
<br>
-// TODO(andydavis) Extend this module to include utility functions for querying<br>
-// fusion cost/storage reduction, and for performing the loop fusion<br>
-// transformation.<br>
+// TODO: Extend this module to include utility functions for querying fusion<br>
+// cost/storage reduction, and for performing the loop fusion transformation.<br>
<br>
struct FusionResult {<br>
enum ResultEnum {<br>
@@ -46,7 +45,7 @@ struct FusionResult {<br>
/// returns a FusionResult explaining why fusion is not feasible.<br>
/// NOTE: This function is not feature complete and should only be used in<br>
/// testing.<br>
-/// TODO(andydavis) Update comments when this function is fully implemented.<br>
+/// TODO: Update comments when this function is fully implemented.<br>
FusionResult canFuseLoops(AffineForOp srcForOp, AffineForOp dstForOp,<br>
unsigned dstLoopDepth,<br>
ComputationSliceState *srcSlice);<br>
@@ -71,14 +70,14 @@ struct LoopNestStats {<br>
/// Collect loop nest statistics (eg. loop trip count and operation count)<br>
/// in 'stats' for loop nest rooted at 'forOp'. Returns true on success,<br>
/// returns false otherwise.<br>
-// TODO(andydavis) Consider moving this to LoopUtils.<br>
+// TODO: Consider moving this to LoopUtils.<br>
bool getLoopNestStats(AffineForOp forOp, LoopNestStats *stats);<br>
<br>
/// Computes the total cost of the loop nest rooted at 'forOp' using 'stats'.<br>
/// Currently, the total cost is computed by counting the total operation<br>
/// instance count (i.e. total number of operations in the loop body * loop<br>
/// trip count) for the entire loop nest.<br>
-// TODO(andydavis) Improve this cost model.<br>
+// TODO: Improve this cost model.<br>
int64_t getComputeCost(AffineForOp forOp, LoopNestStats &stats);<br>
<br>
/// Computes and returns in 'computeCost', the total compute cost of fusing the<br>
@@ -87,7 +86,7 @@ int64_t getComputeCost(AffineForOp forOp, LoopNestStats &stats);<br>
/// (i.e. total number of operations in the loop body * loop trip count) for<br>
/// the entire loop nest.<br>
/// Returns true on success, failure otherwise (e.g. non-constant trip counts).<br>
-// TODO(andydavis) Improve this cost model.<br>
+// TODO: Improve this cost model.<br>
bool getFusionComputeCost(AffineForOp srcForOp, LoopNestStats &srcStats,<br>
AffineForOp dstForOp, LoopNestStats &dstStats,<br>
ComputationSliceState *slice, int64_t *computeCost);<br>
<br>
diff --git a/mlir/include/mlir/Transforms/Utils.h b/mlir/include/mlir/Transforms/Utils.h<br>
index acd5fd9efe41..6f29c1b41ae6 100644<br>
--- a/mlir/include/mlir/Transforms/Utils.h<br>
+++ b/mlir/include/mlir/Transforms/Utils.h<br>
@@ -56,7 +56,7 @@ class OpBuilder;<br>
// d1, d2) -> (d0 - d1, d2), and %ii will be the extra operand. Without any<br>
// extra operands, note that 'indexRemap' would just be applied to existing<br>
// indices (%i, %j).<br>
-// TODO(bondhugula): allow extraIndices to be added at any position.<br>
+// TODO: allow extraIndices to be added at any position.<br>
LogicalResult replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,<br>
ArrayRef<Value> extraIndices = {},<br>
AffineMap indexRemap = AffineMap(),<br>
<br>
diff --git a/mlir/lib/Analysis/AffineAnalysis.cpp b/mlir/lib/Analysis/AffineAnalysis.cpp<br>
index 044c85d4f685..3bacedae80ff 100644<br>
--- a/mlir/lib/Analysis/AffineAnalysis.cpp<br>
+++ b/mlir/lib/Analysis/AffineAnalysis.cpp<br>
@@ -33,8 +33,8 @@ using llvm::dbgs;<br>
/// Returns the sequence of AffineApplyOp Operations operation in<br>
/// 'affineApplyOps', which are reachable via a search starting from 'operands',<br>
/// and ending at operands which are not defined by AffineApplyOps.<br>
-// TODO(andydavis) Add a method to AffineApplyOp which forward substitutes<br>
-// the AffineApplyOp into any user AffineApplyOps.<br>
+// TODO: Add a method to AffineApplyOp which forward substitutes the<br>
+// AffineApplyOp into any user AffineApplyOps.<br>
void mlir::getReachableAffineApplyOps(<br>
ArrayRef<Value> operands, SmallVectorImpl<Operation *> &affineApplyOps) {<br>
struct State {<br>
@@ -81,10 +81,10 @@ void mlir::getReachableAffineApplyOps(<br>
// the loop IVs of the forOps appearing in that order. Any symbols founds in<br>
// the bound operands are added as symbols in the system. Returns failure for<br>
// the yet unimplemented cases.<br>
-// TODO(andydavis,bondhugula) Handle non-unit steps through local variables or<br>
-// stride information in FlatAffineConstraints. (For eg., by using iv - lb %<br>
-// step = 0 and/or by introducing a method in FlatAffineConstraints<br>
-// setExprStride(ArrayRef<int64_t> expr, int64_t stride)<br>
+// TODO: Handle non-unit steps through local variables or stride information in<br>
+// FlatAffineConstraints. (For eg., by using iv - lb % step = 0 and/or by<br>
+// introducing a method in FlatAffineConstraints setExprStride(ArrayRef<int64_t><br>
+// expr, int64_t stride)<br>
LogicalResult mlir::getIndexSet(MutableArrayRef<AffineForOp> forOps,<br>
FlatAffineConstraints *domain) {<br>
SmallVector<Value, 4> indices;<br>
@@ -104,10 +104,10 @@ LogicalResult mlir::getIndexSet(MutableArrayRef<AffineForOp> forOps,<br>
// potentially involving any Function symbols. The dimensional identifiers in<br>
// 'indexSet' correspond to the loops surrounding 'op' from outermost to<br>
// innermost.<br>
-// TODO(andydavis) Add support to handle IfInsts surrounding 'op'.<br>
+// TODO: Add support to handle IfInsts surrounding 'op'.<br>
static LogicalResult getInstIndexSet(Operation *op,<br>
FlatAffineConstraints *indexSet) {<br>
- // TODO(andydavis) Extend this to gather enclosing IfInsts and consider<br>
+ // TODO: Extend this to gather enclosing IfInsts and consider<br>
// factoring it out into a utility function.<br>
SmallVector<AffineForOp, 4> loops;<br>
getLoopIVs(*op, &loops);<br>
@@ -130,9 +130,9 @@ namespace {<br>
// an Value in multiple maps are provided (i.e. getSrcDimOrSymPos) to handle<br>
// the common case of resolving positions for all access function operands.<br>
//<br>
-// TODO(andydavis) Generalize this: could take a template parameter for<br>
-// the number of maps (3 in the current case), and lookups could take indices<br>
-// of maps to check. So getSrcDimOrSymPos would be "getPos(value, {0, 2})".<br>
+// TODO: Generalize this: could take a template parameter for the number of maps<br>
+// (3 in the current case), and lookups could take indices of maps to check. So<br>
+// getSrcDimOrSymPos would be "getPos(value, {0, 2})".<br>
class ValuePositionMap {<br>
public:<br>
void addSrcValue(Value value) {<br>
@@ -758,7 +758,7 @@ void MemRefAccess::getAccessMap(AffineValueMap *accessMap) const {<br>
// 0 0 0 -1 0 0 0 50 >= 0<br>
//<br>
//<br>
-// TODO(andydavis) Support AffineExprs mod/floordiv/ceildiv.<br>
+// TODO: Support AffineExprs mod/floordiv/ceildiv.<br>
DependenceResult mlir::checkMemrefAccessDependence(<br>
const MemRefAccess &srcAccess, const MemRefAccess &dstAccess,<br>
unsigned loopDepth, FlatAffineConstraints *dependenceConstraints,<br>
@@ -874,8 +874,8 @@ void mlir::getDependenceComponents(<br>
<br>
FlatAffineConstraints dependenceConstraints;<br>
SmallVector<DependenceComponent, 2> depComps;<br>
- // TODO(andydavis,bondhugula) Explore whether it would be profitable<br>
- // to pre-compute and store deps instead of repeatedly checking.<br>
+ // TODO: Explore whether it would be profitable to pre-compute and store<br>
+ // deps instead of repeatedly checking.<br>
DependenceResult result = checkMemrefAccessDependence(<br>
srcAccess, dstAccess, d, &dependenceConstraints, &depComps);<br>
if (hasDependence(result))<br>
<br>
diff --git a/mlir/lib/Analysis/AffineStructures.cpp b/mlir/lib/Analysis/AffineStructures.cpp<br>
index f297f6b11d63..c09a9af45712 100644<br>
--- a/mlir/lib/Analysis/AffineStructures.cpp<br>
+++ b/mlir/lib/Analysis/AffineStructures.cpp<br>
@@ -894,7 +894,7 @@ void FlatAffineConstraints::removeIdRange(unsigned idStart, unsigned idLimit) {<br>
// We are going to be removing one or more identifiers from the range.<br>
assert(idStart < numIds && "invalid idStart position");<br>
<br>
- // TODO(andydavis) Make 'removeIdRange' a lambda called from here.<br>
+ // TODO: Make 'removeIdRange' a lambda called from here.<br>
// Remove eliminated identifiers from equalities.<br>
shiftColumnsToLeft(this, idStart, idLimit, /*isEq=*/true);<br>
<br>
@@ -1173,8 +1173,8 @@ static bool detectAsMod(const FlatAffineConstraints &cst, unsigned pos,<br>
if (c == pos)<br>
continue;<br>
// The coefficient of the quotient should be +/-divisor.<br>
- // TODO(bondhugula): could be extended to detect an affine function for<br>
- // the quotient (i.e., the coeff could be a non-zero multiple of divisor).<br>
+ // TODO: could be extended to detect an affine function for the quotient<br>
+ // (i.e., the coeff could be a non-zero multiple of divisor).<br>
int64_t v = cst.atEq(r, c) * cst.atEq(r, pos);<br>
if (v == divisor || v == -divisor) {<br>
seenQuotient++;<br>
@@ -1182,8 +1182,8 @@ static bool detectAsMod(const FlatAffineConstraints &cst, unsigned pos,<br>
quotientSign = v > 0 ? 1 : -1;<br>
}<br>
// The coefficient of the dividend should be +/-1.<br>
- // TODO(bondhugula): could be extended to detect an affine function of<br>
- // the other identifiers as the dividend.<br>
+ // TODO: could be extended to detect an affine function of the other<br>
+ // identifiers as the dividend.<br>
else if (v == -1 || v == 1) {<br>
seenDividend++;<br>
dividendPos = c;<br>
@@ -1342,8 +1342,8 @@ static bool detectAsFloorDiv(const FlatAffineConstraints &cst, unsigned pos,<br>
}<br>
// Expression can't be constructed as it depends on a yet unknown<br>
// identifier.<br>
- // TODO(mlir-team): Visit/compute the identifiers in an order so that<br>
- // this doesn't happen. More complex but much more efficient.<br>
+ // TODO: Visit/compute the identifiers in an order so that this doesn't<br>
+ // happen. More complex but much more efficient.<br>
if (c < f)<br>
continue;<br>
// Successfully detected the floordiv.<br>
@@ -1619,9 +1619,9 @@ void FlatAffineConstraints::getSliceBounds(unsigned offset, unsigned num,<br>
lbMap = AffineMap::get(numMapDims, numMapSymbols, expr);<br>
ubMap = AffineMap::get(numMapDims, numMapSymbols, expr + 1);<br>
} else {<br>
- // TODO(bondhugula): Whenever there are local identifiers in the<br>
- // dependence constraints, we'll conservatively over-approximate, since we<br>
- // don't always explicitly compute them above (in the while loop).<br>
+ // TODO: Whenever there are local identifiers in the dependence<br>
+ // constraints, we'll conservatively over-approximate, since we don't<br>
+ // always explicitly compute them above (in the while loop).<br>
if (getNumLocalIds() == 0) {<br>
// Work on a copy so that we don't update this constraint system.<br>
if (!tmpClone) {<br>
@@ -1636,7 +1636,7 @@ void FlatAffineConstraints::getSliceBounds(unsigned offset, unsigned num,<br>
<br>
// If the above fails, we'll just use the constant lower bound and the<br>
// constant upper bound (if they exist) as the slice bounds.<br>
- // TODO(b/126426796): being conservative for the moment in cases that<br>
+ // TODO: being conservative for the moment in cases that<br>
// lead to multiple bounds - until getConstDifference in LoopFusion.cpp is<br>
// fixed (b/126426796).<br>
if (!lbMap || lbMap.getNumResults() > 1) {<br>
@@ -2356,8 +2356,8 @@ void FlatAffineConstraints::removeTrivialRedundancy() {<br>
}<br>
inequalities.resize(numReservedCols * pos);<br>
<br>
- // TODO(bondhugula): consider doing this for equalities as well, but probably<br>
- // not worth the savings.<br>
+ // TODO: consider doing this for equalities as well, but probably not worth<br>
+ // the savings.<br>
}<br>
<br>
void FlatAffineConstraints::clearAndCopyFrom(<br>
@@ -2434,8 +2434,8 @@ getNewNumDimsSymbols(unsigned pos, const FlatAffineConstraints &cst) {<br>
/// holes/splinters: j = 2<br>
///<br>
/// darkShadow = false, isResultIntegerExact = nullptr are default values.<br>
-// TODO(bondhugula): a slight modification to yield dark shadow version of FM<br>
-// (tightened), which can prove the existence of a solution if there is one.<br>
+// TODO: a slight modification to yield dark shadow version of FM (tightened),<br>
+// which can prove the existence of a solution if there is one.<br>
void FlatAffineConstraints::FourierMotzkinEliminate(<br>
unsigned pos, bool darkShadow, bool *isResultIntegerExact) {<br>
LLVM_DEBUG(llvm::dbgs() << "FM input (eliminate pos " << pos << "):\n");<br>
@@ -2467,7 +2467,7 @@ void FlatAffineConstraints::FourierMotzkinEliminate(<br>
}<br>
if (r == getNumInequalities()) {<br>
// If it doesn't appear, just remove the column and return.<br>
- // TODO(andydavis,bondhugula): refactor removeColumns to use it from here.<br>
+ // TODO: refactor removeColumns to use it from here.<br>
removeId(pos);<br>
LLVM_DEBUG(llvm::dbgs() << "FM output:\n");<br>
LLVM_DEBUG(dump());<br>
@@ -2538,7 +2538,7 @@ void FlatAffineConstraints::FourierMotzkinEliminate(<br>
// coefficient in the canonical form as the view taken here is that of the<br>
// term being moved to the other size of '>='.<br>
int64_t ubCoeff = -atIneq(ubPos, pos);<br>
- // TODO(bondhugula): refactor this loop to avoid all branches inside.<br>
+ // TODO: refactor this loop to avoid all branches inside.<br>
for (unsigned l = 0, e = getNumCols(); l < e; l++) {<br>
if (l == pos)<br>
continue;<br>
@@ -2742,14 +2742,14 @@ FlatAffineConstraints::unionBoundingBox(const FlatAffineConstraints &otherCst) {<br>
for (unsigned d = 0, e = getNumDimIds(); d < e; ++d) {<br>
auto extent = getConstantBoundOnDimSize(d, &lb, &lbFloorDivisor, &ub);<br>
if (!extent.hasValue())<br>
- // TODO(bondhugula): symbolic extents when necessary.<br>
- // TODO(bondhugula): handle union if a dimension is unbounded.<br>
+ // TODO: symbolic extents when necessary.<br>
+ // TODO: handle union if a dimension is unbounded.<br>
return failure();<br>
<br>
auto otherExtent = otherAligned.getConstantBoundOnDimSize(<br>
d, &otherLb, &otherLbFloorDivisor, &otherUb);<br>
if (!otherExtent.hasValue() || lbFloorDivisor != otherLbFloorDivisor)<br>
- // TODO(bondhugula): symbolic extents when necessary.<br>
+ // TODO: symbolic extents when necessary.<br>
return failure();<br>
<br>
assert(lbFloorDivisor > 0 && "divisor always expected to be positive");<br>
@@ -2819,9 +2819,9 @@ FlatAffineConstraints::unionBoundingBox(const FlatAffineConstraints &otherCst) {<br>
append(commonCst);<br>
removeTrivialRedundancy();<br>
<br>
- // TODO(mlir-team): copy over pure symbolic constraints from this and 'other'<br>
- // over to the union (since the above are just the union along dimensions); we<br>
- // shouldn't be discarding any other constraints on the symbols.<br>
+ // TODO: copy over pure symbolic constraints from this and 'other' over to the<br>
+ // union (since the above are just the union along dimensions); we shouldn't<br>
+ // be discarding any other constraints on the symbols.<br>
<br>
return success();<br>
}<br>
<br>
diff --git a/mlir/lib/Analysis/LoopAnalysis.cpp b/mlir/lib/Analysis/LoopAnalysis.cpp<br>
index 8975a0796356..210b68eae3cb 100644<br>
--- a/mlir/lib/Analysis/LoopAnalysis.cpp<br>
+++ b/mlir/lib/Analysis/LoopAnalysis.cpp<br>
@@ -213,7 +213,7 @@ DenseSet<Value> mlir::getInvariantAccesses(Value iv, ArrayRef<Value> indices) {<br>
/// Returns false if the MemRef has a non-identity layoutMap or more than 1<br>
/// layoutMap. This is conservative.<br>
///<br>
-// TODO(ntv): check strides.<br>
+// TODO: check strides.<br>
template <typename LoadOrStoreOp><br>
static bool isContiguousAccess(Value iv, LoadOrStoreOp memoryOp,<br>
int *memRefDim) {<br>
@@ -224,8 +224,7 @@ static bool isContiguousAccess(Value iv, LoadOrStoreOp memoryOp,<br>
auto memRefType = memoryOp.getMemRefType();<br>
<br>
auto layoutMap = memRefType.getAffineMaps();<br>
- // TODO(ntv): remove dependence on Builder once we support non-identity<br>
- // layout map.<br>
+ // TODO: remove dependence on Builder once we support non-identity layout map.<br>
Builder b(memoryOp.getContext());<br>
if (layoutMap.size() >= 2 ||<br>
(layoutMap.size() == 1 &&<br>
@@ -314,7 +313,7 @@ isVectorizableLoopBodyWithOpCond(AffineForOp loop,<br>
auto store = dyn_cast<AffineStoreOp>(op);<br>
// Only scalar types are considered vectorizable, all load/store must be<br>
// vectorizable for a loop to qualify as vectorizable.<br>
- // TODO(ntv): ponder whether we want to be more general here.<br>
+ // TODO: ponder whether we want to be more general here.<br>
bool vector = load ? isVectorElement(load) : isVectorElement(store);<br>
if (vector) {<br>
return false;<br>
@@ -345,8 +344,8 @@ bool mlir::isVectorizableLoopBody(AffineForOp loop,<br>
/// Checks whether SSA dominance would be violated if a for op's body<br>
/// operations are shifted by the specified shifts. This method checks if a<br>
/// 'def' and all its uses have the same shift factor.<br>
-// TODO(mlir-team): extend this to check for memory-based dependence violation<br>
-// when we have the support.<br>
+// TODO: extend this to check for memory-based dependence violation when we have<br>
+// the support.<br>
bool mlir::isOpwiseShiftValid(AffineForOp forOp, ArrayRef<uint64_t> shifts) {<br>
auto *forBody = forOp.getBody();<br>
assert(shifts.size() == forBody->getOperations().size());<br>
<br>
diff --git a/mlir/lib/Analysis/NestedMatcher.cpp b/mlir/lib/Analysis/NestedMatcher.cpp<br>
index e745ac7190e5..7e15ea1094c9 100644<br>
--- a/mlir/lib/Analysis/NestedMatcher.cpp<br>
+++ b/mlir/lib/Analysis/NestedMatcher.cpp<br>
@@ -68,8 +68,8 @@ unsigned NestedPattern::getDepth() const {<br>
/// 3. if all is good, recursively matches the nested patterns;<br>
/// 4. if all nested match then the single operation matches too and is<br>
/// appended to the list of matches;<br>
-/// 5. TODO(ntv) Optionally applies actions (lambda), in which case we will<br>
-/// want to traverse in post-order DFS to avoid invalidating iterators.<br>
+/// 5. TODO: Optionally applies actions (lambda), in which case we will want<br>
+/// to traverse in post-order DFS to avoid invalidating iterators.<br>
void NestedPattern::matchOne(Operation *op,<br>
SmallVectorImpl<NestedMatch> *matches) {<br>
if (skip == op) {<br>
<br>
diff --git a/mlir/lib/Analysis/Utils.cpp b/mlir/lib/Analysis/Utils.cpp<br>
index ab273f8d95d5..861976567d56 100644<br>
--- a/mlir/lib/Analysis/Utils.cpp<br>
+++ b/mlir/lib/Analysis/Utils.cpp<br>
@@ -191,7 +191,7 @@ LogicalResult MemRefRegion::unionBoundingBox(const MemRefRegion &other) {<br>
// region: {memref = %A, write = false, {%i <= m0 <= %i + 7} }<br>
// The last field is a 2-d FlatAffineConstraints symbolic in %i.<br>
//<br>
-// TODO(bondhugula): extend this to any other memref dereferencing ops<br>
+// TODO: extend this to any other memref dereferencing ops<br>
// (dma_start, dma_wait).<br>
LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,<br>
ComputationSliceState *sliceState,<br>
@@ -258,7 +258,7 @@ LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,<br>
if (auto loop = getForInductionVarOwner(operand)) {<br>
// Note that cst can now have more dimensions than accessMap if the<br>
// bounds expressions involve outer loops or other symbols.<br>
- // TODO(bondhugula): rewrite this to use getInstIndexSet; this way<br>
+ // TODO: rewrite this to use getInstIndexSet; this way<br>
// conditionals will be handled when the latter supports it.<br>
if (failed(cst.addAffineForOpDomain(loop)))<br>
return failure();<br>
@@ -330,7 +330,7 @@ LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,<br>
<br>
// Add upper/lower bounds for each memref dimension with static size<br>
// to guard against potential over-approximation from projection.<br>
- // TODO(andydavis) Support dynamic memref dimensions.<br>
+ // TODO: Support dynamic memref dimensions.<br>
if (addMemRefDimBounds) {<br>
auto memRefType = memref.getType().cast<MemRefType>();<br>
for (unsigned r = 0; r < rank; r++) {<br>
@@ -390,7 +390,7 @@ Optional<int64_t> MemRefRegion::getRegionSize() {<br>
/// Returns the size of memref data in bytes if it's statically shaped, None<br>
/// otherwise. If the element of the memref has vector type, takes into account<br>
/// size of the vector as well.<br>
-// TODO(mlir-team): improve/complete this when we have target data.<br>
+// TODO: improve/complete this when we have target data.<br>
Optional<uint64_t> mlir::getMemRefSizeInBytes(MemRefType memRefType) {<br>
if (!memRefType.hasStaticShape())<br>
return None;<br>
@@ -434,7 +434,7 @@ LogicalResult mlir::boundCheckLoadOrStoreOp(LoadOrStoreOp loadOrStoreOp,<br>
// feasible. If it is, there is at least one point out of bounds.<br>
SmallVector<int64_t, 4> ineq(rank + 1, 0);<br>
int64_t dimSize = loadOrStoreOp.getMemRefType().getDimSize(r);<br>
- // TODO(bondhugula): handle dynamic dim sizes.<br>
+ // TODO: handle dynamic dim sizes.<br>
if (dimSize == -1)<br>
continue;<br>
<br>
@@ -525,7 +525,7 @@ static LogicalResult addMissingLoopIVBounds(SmallPtrSet<Value, 8> &ivs,<br>
}<br>
<br>
// Returns the innermost common loop depth for the set of operations in 'ops'.<br>
-// TODO(andydavis) Move this to LoopUtils.<br>
+// TODO: Move this to LoopUtils.<br>
static unsigned<br>
getInnermostCommonLoopDepth(ArrayRef<Operation *> ops,<br>
SmallVectorImpl<AffineForOp> &surroundingLoops) {<br>
@@ -782,7 +782,7 @@ void mlir::getComputationSliceState(<br>
}<br>
// Clear all sliced loop bounds beginning at the first sequential loop, or<br>
// first loop with a slice fusion barrier attribute..<br>
- // TODO(andydavis, bondhugula) Use MemRef read/write regions instead of<br>
+ // TODO: Use MemRef read/write regions instead of<br>
// using 'kSliceFusionBarrierAttrName'.<br>
auto getSliceLoop = [&](unsigned i) {<br>
return isBackwardSlice ? srcLoopIVs[i] : dstLoopIVs[i];<br>
@@ -804,10 +804,10 @@ void mlir::getComputationSliceState(<br>
/// updates the slice loop bounds with any non-null bound maps specified in<br>
/// 'sliceState', and inserts this slice into the loop nest surrounding<br>
/// 'dstOpInst' at loop depth 'dstLoopDepth'.<br>
-// TODO(andydavis,bondhugula): extend the slicing utility to compute slices that<br>
+// TODO: extend the slicing utility to compute slices that<br>
// aren't necessarily a one-to-one relation b/w the source and destination. The<br>
// relation between the source and destination could be many-to-many in general.<br>
-// TODO(andydavis,bondhugula): the slice computation is incorrect in the cases<br>
+// TODO: the slice computation is incorrect in the cases<br>
// where the dependence from the source to the destination does not cover the<br>
// entire destination index set. Subtract out the dependent destination<br>
// iterations from destination index set and check for emptiness --- this is one<br>
@@ -832,7 +832,7 @@ mlir::insertBackwardComputationSlice(Operation *srcOpInst, Operation *dstOpInst,<br>
<br>
// Find the op block positions of 'srcOpInst' within 'srcLoopIVs'.<br>
SmallVector<unsigned, 4> positions;<br>
- // TODO(andydavis): This code is incorrect since srcLoopIVs can be 0-d.<br>
+ // TODO: This code is incorrect since srcLoopIVs can be 0-d.<br>
findInstPosition(srcOpInst, srcLoopIVs[0].getOperation()->getBlock(),<br>
&positions);<br>
<br>
<br>
diff --git a/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp b/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp<br>
index b65118b72fdf..a8c483430fce 100644<br>
--- a/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp<br>
+++ b/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp<br>
@@ -30,7 +30,7 @@ static Type getSrcVectorElementType(OpTy op) {<br>
return op.src().getType().template cast<VectorType>().getElementType();<br>
}<br>
<br>
-// TODO(ntv, zinenko): Code is currently copy-pasted and adapted from the code<br>
+// TODO: Code is currently copy-pasted and adapted from the code<br>
// 1-1 LLVM conversion. It would better if it were properly exposed in core and<br>
// reusable.<br>
/// Basic lowering implementation for one-to-one rewriting from AVX512 Ops to<br>
@@ -76,7 +76,7 @@ matchAndRewriteOneToOne(const ConvertToLLVMPattern &lowering,<br>
}<br>
<br>
namespace {<br>
-// TODO(ntv): Patterns are too verbose due to the fact that we have 1 op (e.g.<br>
+// TODO: Patterns are too verbose due to the fact that we have 1 op (e.g.<br>
// MaskRndScaleOp) and <br>
diff erent possible target ops. It would be better to take<br>
// a Functor so that all these conversions become 1-liners.<br>
struct MaskRndScaleOpPS512Conversion : public ConvertToLLVMPattern {<br>
<br>
diff --git a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp<br>
index feaa38259e01..afb6d2875866 100644<br>
--- a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp<br>
+++ b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp<br>
@@ -140,7 +140,7 @@ struct LowerGpuOpsToNVVMOpsPass<br>
LLVM::LogOp, LLVM::Log10Op, LLVM::Log2Op>();<br>
target.addIllegalOp<FuncOp>();<br>
target.addLegalDialect<NVVM::NVVMDialect>();<br>
- // TODO(csigg): Remove once we support replacing non-root ops.<br>
+ // TODO: Remove once we support replacing non-root ops.<br>
target.addLegalOp<gpu::YieldOp, gpu::GPUModuleOp, gpu::ModuleEndOp>();<br>
if (failed(applyPartialConversion(m, target, patterns)))<br>
signalPassFailure();<br>
<br>
diff --git a/mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp b/mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp<br>
index 8a1d10f0eb03..697f8078e725 100644<br>
--- a/mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp<br>
+++ b/mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp<br>
@@ -74,7 +74,7 @@ struct LowerGpuOpsToROCDLOpsPass<br>
LLVM::LogOp, LLVM::Log10Op, LLVM::Log2Op>();<br>
target.addIllegalOp<FuncOp>();<br>
target.addLegalDialect<ROCDL::ROCDLDialect>();<br>
- // TODO(whchung): Remove once we support replacing non-root ops.<br>
+ // TODO: Remove once we support replacing non-root ops.<br>
target.addLegalOp<gpu::YieldOp, gpu::GPUModuleOp, gpu::ModuleEndOp>();<br>
if (failed(applyPartialConversion(m, target, patterns)))<br>
signalPassFailure();<br>
<br>
diff --git a/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp b/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp<br>
index b92ab13bd513..7b57854dde98 100644<br>
--- a/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp<br>
+++ b/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp<br>
@@ -219,7 +219,7 @@ class SliceOpConversion : public ConvertToLLVMPattern {<br>
BaseViewConversionHelper desc(<br>
typeConverter.convertType(sliceOp.getShapedType()));<br>
<br>
- // TODO(ntv): extract sizes and emit asserts.<br>
+ // TODO: extract sizes and emit asserts.<br>
SmallVector<Value, 4> strides(memRefType.getRank());<br>
for (int i = 0, e = memRefType.getRank(); i < e; ++i)<br>
strides[i] = baseDesc.stride(i);<br>
<br>
diff --git a/mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp b/mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp<br>
index cf67b96fce1e..0cde4a05ece5 100644<br>
--- a/mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp<br>
+++ b/mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp<br>
@@ -92,7 +92,7 @@ SingleWorkgroupReduction::matchAsPerformingReduction(<br>
if (genericOp.indexing_maps().getValue().size() != 2)<br>
return llvm::None;<br>
<br>
- // TODO(nicolasvasilache): create utility functions for these checks in Linalg<br>
+ // TODO: create utility functions for these checks in Linalg<br>
// and use them.<br>
auto inputMap = genericOp.indexing_maps().getValue()[0].cast<AffineMapAttr>();<br>
auto outputMap =<br>
@@ -132,7 +132,7 @@ LogicalResult SingleWorkgroupReduction::matchAndRewrite(<br>
[](const APInt &size) { return !size.isOneValue(); }))<br>
return failure();<br>
<br>
- // TODO(antiagainst): Query the target environment to make sure the current<br>
+ // TODO: Query the target environment to make sure the current<br>
// workload fits in a local workgroup.<br>
<br>
Value convertedInput = operands[0], convertedOutput = operands[1];<br>
@@ -141,7 +141,7 @@ LogicalResult SingleWorkgroupReduction::matchAndRewrite(<br>
// Get the invocation ID.<br>
Value x = getLocalInvocationDimSize(genericOp, /*dim=*/0, loc, &rewriter);<br>
<br>
- // TODO(antiagainst): Load to Workgroup storage class first.<br>
+ // TODO: Load to Workgroup storage class first.<br>
<br>
// Get the input element accessed by this invocation.<br>
Value inputElementPtr = spirv::getElementPtr(<br>
<br>
diff --git a/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp b/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp<br>
index 7f13a7a609e9..75b8466ff7fd 100644<br>
--- a/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp<br>
+++ b/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp<br>
@@ -173,7 +173,7 @@ class LinalgOpConversion<IndexedGenericOp><br>
if (!libraryCallName)<br>
return failure();<br>
<br>
- // TODO(pifon, ntv): Use induction variables values instead of zeros, when<br>
+ // TODO: Use induction variables values instead of zeros, when<br>
// IndexedGenericOp is tiled.<br>
auto zero = rewriter.create<mlir::ConstantOp>(<br>
op.getLoc(), rewriter.getIntegerAttr(rewriter.getIndexType(), 0));<br>
@@ -227,7 +227,7 @@ class CopyTransposeConversion : public OpRewritePattern<CopyOp> {<br>
/// Populate the given list with patterns that convert from Linalg to Standard.<br>
void mlir::populateLinalgToStandardConversionPatterns(<br>
OwningRewritePatternList &patterns, MLIRContext *ctx) {<br>
- // TODO(ntv) ConvOp conversion needs to export a descriptor with relevant<br>
+ // TODO: ConvOp conversion needs to export a descriptor with relevant<br>
// attribute values such as kernel striding and dilation.<br>
// clang-format off<br>
patterns.insert<<br>
<br>
diff --git a/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp b/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp<br>
index 4acce99ce2dc..0a657e5387b2 100644<br>
--- a/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp<br>
+++ b/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp<br>
@@ -378,12 +378,12 @@ static LogicalResult processParallelLoop(<br>
ParallelOp parallelOp, gpu::LaunchOp launchOp,<br>
BlockAndValueMapping &cloningMap, SmallVectorImpl<Operation *> &worklist,<br>
DenseMap<gpu::Processor, Value> &bounds, PatternRewriter &rewriter) {<br>
- // TODO(herhut): Verify that this is a valid GPU mapping.<br>
+ // TODO: Verify that this is a valid GPU mapping.<br>
// processor ids: 0-2 block [x/y/z], 3-5 -> thread [x/y/z], 6-> sequential<br>
ArrayAttr mapping =<br>
parallelOp.getAttrOfType<ArrayAttr>(gpu::getMappingAttrName());<br>
<br>
- // TODO(herhut): Support reductions.<br>
+ // TODO: Support reductions.<br>
if (!mapping || parallelOp.getNumResults() != 0)<br>
return failure();<br>
<br>
@@ -431,7 +431,7 @@ static LogicalResult processParallelLoop(<br>
loc, annotation.map().getValue().compose(lowerAndStep),<br>
ValueRange{operand, step, lowerBound});<br>
// If there was also a bound, insert that, too.<br>
- // TODO(herhut): Check that we do not assign bounds twice.<br>
+ // TODO: Check that we do not assign bounds twice.<br>
if (annotation.bound().getValue()) {<br>
// We pass as the single operand to the bound-map the number of<br>
// iterations, which is (upperBound - lowerBound) ceilDiv step. To<br>
<br>
diff --git a/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp b/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp<br>
index ee98bc9166f8..91a4867ad307 100644<br>
--- a/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp<br>
+++ b/mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp<br>
@@ -331,7 +331,7 @@ LLVMTypeConverter::convertFunctionTypeCWrapper(FunctionType type) {<br>
// 4. a second array containing as many `index`-type integers as the rank of<br>
// the MemRef: the second array represents the "stride" (in tensor abstraction<br>
// sense), i.e. the number of consecutive elements of the underlying buffer.<br>
-// TODO(ntv, zinenko): add assertions for the static cases.<br>
+// TODO: add assertions for the static cases.<br>
//<br>
// template <typename Elem, size_t Rank><br>
// struct {<br>
<br>
diff --git a/mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp b/mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp<br>
index aac275548891..6bb7a17ae46f 100644<br>
--- a/mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp<br>
+++ b/mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp<br>
@@ -536,7 +536,7 @@ LogicalResult ConstantCompositeOpPattern::matchAndRewrite(<br>
srcType.getElementType());<br>
dstElementsAttr = dstElementsAttr.reshape(dstAttrType);<br>
} else {<br>
- // TODO(antiagainst): add support for large vectors.<br>
+ // TODO: add support for large vectors.<br>
return failure();<br>
}<br>
}<br>
<br>
diff --git a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp<br>
index 6b43a1e1fdc1..9a66dafc345a 100644<br>
--- a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp<br>
+++ b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp<br>
@@ -110,7 +110,7 @@ static Value extractOne(PatternRewriter &rewriter, Location loc, Value vector,<br>
}<br>
<br>
// Helper that returns a subset of `arrayAttr` as a vector of int64_t.<br>
-// TODO(rriddle): Better support for attribute subtype forwarding + slicing.<br>
+// TODO: Better support for attribute subtype forwarding + slicing.<br>
static SmallVector<int64_t, 4> getI64SubArray(ArrayAttr arrayAttr,<br>
unsigned dropFront = 0,<br>
unsigned dropBack = 0) {<br>
@@ -927,7 +927,7 @@ class VectorTransferConversion : public ConvertToLLVMPattern {<br>
loc, toLLVMTy(vectorCmpType), linearIndices);<br>
<br>
// 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].<br>
- // TODO(ntv, ajcbik): when the leaf transfer rank is k > 1 we need the last<br>
+ // TODO: when the leaf transfer rank is k > 1 we need the last<br>
// `k` dimensions here.<br>
unsigned lastIndex = llvm::size(xferOp.indices()) - 1;<br>
Value offsetIndex = *(xferOp.indices().begin() + lastIndex);<br>
@@ -968,7 +968,7 @@ class VectorPrintOpConversion : public ConvertToLLVMPattern {<br>
// output of any shaped and dimensioned vector. Due to full unrolling,<br>
// this approach is less suited for very large vectors though.<br>
//<br>
- // TODO(ajcbik): rely solely on libc in future? something else?<br>
+ // TODO: rely solely on libc in future? something else?<br>
//<br>
LogicalResult<br>
matchAndRewrite(Operation *op, ArrayRef<Value> operands,<br>
<br>
diff --git a/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp b/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp<br>
index c7b4db1d5ce3..24e1d66e3605 100644<br>
--- a/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp<br>
+++ b/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp<br>
@@ -86,7 +86,7 @@ class NDTransferOpHelper {<br>
scope(std::make_unique<ScopedContext>(rewriter, loc)), xferOp(xferOp),<br>
op(xferOp.getOperation()) {<br>
vectorType = xferOp.getVectorType();<br>
- // TODO(ntv, ajcbik): when we go to k > 1-D vectors adapt minorRank.<br>
+ // TODO: when we go to k > 1-D vectors adapt minorRank.<br>
minorRank = 1;<br>
majorRank = vectorType.getRank() - minorRank;<br>
leadingRank = xferOp.getMemRefType().getRank() - (majorRank + minorRank);<br>
@@ -528,8 +528,8 @@ MemRefType VectorTransferRewriter<TransferOpTy>::tmpMemRefType(<br>
/// in the presence of data-parallel only operations, we generate code that<br>
/// writes the same value multiple time on the edge locations.<br>
///<br>
-/// TODO(ntv): implement alternatives to clipping.<br>
-/// TODO(ntv): support non-data-parallel operations.<br>
+/// TODO: implement alternatives to clipping.<br>
+/// TODO: support non-data-parallel operations.<br>
<br>
/// Performs the rewrite.<br>
template <><br>
@@ -603,8 +603,8 @@ LogicalResult VectorTransferRewriter<TransferReadOp>::matchAndRewrite(<br>
/// See `Important notes about clipping and full-tiles only abstraction` in the<br>
/// description of `readClipped` above.<br>
///<br>
-/// TODO(ntv): implement alternatives to clipping.<br>
-/// TODO(ntv): support non-data-parallel operations.<br>
+/// TODO: implement alternatives to clipping.<br>
+/// TODO: support non-data-parallel operations.<br>
template <><br>
LogicalResult VectorTransferRewriter<TransferWriteOp>::matchAndRewrite(<br>
Operation *op, PatternRewriter &rewriter) const {<br>
<br>
diff --git a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp<br>
index b4c1f7aa35a0..3f10e744f419 100644<br>
--- a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp<br>
+++ b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp<br>
@@ -467,7 +467,7 @@ indicesFromAffineApplyOp(ArrayRef<Value> operands) {<br>
// of allowing mathematical AffineMap composition.<br>
// Returns an AffineMap where symbols that come from an AffineApplyOp have been<br>
// rewritten as dims and are ordered after the original dims.<br>
-// TODO(andydavis,ntv): This promotion makes AffineMap lose track of which<br>
+// TODO: This promotion makes AffineMap lose track of which<br>
// symbols are represented as dims. This loss is static but can still be<br>
// recovered dynamically (with `isValidSymbol`). Still this is annoying for the<br>
// semi-affine map case. A dynamic canonicalization of all dims that are valid<br>
@@ -536,7 +536,7 @@ static AffineMap promoteComposedSymbolsAsDims(AffineMap map,<br>
/// composition via symbols, which is ambiguous mathematically. This corner case<br>
/// is handled by locally rewriting such symbols that come from AffineApplyOp<br>
/// into dims and composing through dims.<br>
-/// TODO(andydavis, ntv): Composition via symbols comes at a significant code<br>
+/// TODO: Composition via symbols comes at a significant code<br>
/// complexity. Alternatively we should investigate whether we want to<br>
/// explicitly disallow symbols coming from affine.apply and instead force the<br>
/// user to compose symbols beforehand. The annoyances may be small (i.e. 1 or 2<br>
@@ -647,7 +647,7 @@ AffineApplyNormalizer::AffineApplyNormalizer(AffineMap map,<br>
LLVM_DEBUG(auxiliaryMap.print(dbgs() << "\nWith map: "));<br>
LLVM_DEBUG(map.compose(auxiliaryMap).print(dbgs() << "\nResult: "));<br>
<br>
- // TODO(andydavis,ntv): Disabling simplification results in major speed gains.<br>
+ // TODO: Disabling simplification results in major speed gains.<br>
// Another option is to cache the results as it is expected a lot of redundant<br>
// work is performed in practice.<br>
affineMap = simplifyAffineMap(map.compose(auxiliaryMap));<br>
@@ -928,7 +928,7 @@ static LogicalResult foldMemRefCast(Operation *op) {<br>
// AffineDmaStartOp<br>
//===----------------------------------------------------------------------===//<br>
<br>
-// TODO(b/133776335) Check that map operands are loop IVs or symbols.<br>
+// TODO: Check that map operands are loop IVs or symbols.<br>
void AffineDmaStartOp::build(OpBuilder &builder, OperationState &result,<br>
Value srcMemRef, AffineMap srcMap,<br>
ValueRange srcIndices, Value destMemRef,<br>
@@ -1098,7 +1098,7 @@ LogicalResult AffineDmaStartOp::fold(ArrayRef<Attribute> cstOperands,<br>
// AffineDmaWaitOp<br>
//===----------------------------------------------------------------------===//<br>
<br>
-// TODO(b/133776335) Check that map operands are loop IVs or symbols.<br>
+// TODO: Check that map operands are loop IVs or symbols.<br>
void AffineDmaWaitOp::build(OpBuilder &builder, OperationState &result,<br>
Value tagMemRef, AffineMap tagMap,<br>
ValueRange tagIndices, Value numElements) {<br>
@@ -2196,7 +2196,7 @@ static OpFoldResult foldMinMaxOp(T op, ArrayRef<Attribute> operands) {<br>
"expected affine min or max op");<br>
<br>
// Fold the affine map.<br>
- // TODO(andydavis, ntv) Fold more cases:<br>
+ // TODO: Fold more cases:<br>
// min(some_affine, some_affine + constant, ...), etc.<br>
SmallVector<int64_t, 2> results;<br>
auto foldedMap = op.map().partialConstantFold(operands, &results);<br>
<br>
diff --git a/mlir/lib/Dialect/Affine/IR/AffineValueMap.cpp b/mlir/lib/Dialect/Affine/IR/AffineValueMap.cpp<br>
index 792ca379cef4..6f7c2fbc56ff 100644<br>
--- a/mlir/lib/Dialect/Affine/IR/AffineValueMap.cpp<br>
+++ b/mlir/lib/Dialect/Affine/IR/AffineValueMap.cpp<br>
@@ -85,7 +85,7 @@ bool AffineValueMap::isFunctionOf(unsigned idx, Value value) const {<br>
return false;<br>
}<br>
auto expr = const_cast<AffineValueMap *>(this)->getAffineMap().getResult(idx);<br>
- // TODO(ntv): this is better implemented on a flattened representation.<br>
+ // TODO: this is better implemented on a flattened representation.<br>
// At least for now it is conservative.<br>
return expr.isFunctionOfDim(index);<br>
}<br>
<br>
diff --git a/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp b/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp<br>
index ea66fcb3b090..f438630a6e55 100644<br>
--- a/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp<br>
+++ b/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp<br>
@@ -46,7 +46,7 @@ namespace {<br>
/// inner levels if necessary to determine at what depth copies need to be<br>
/// placed so that the allocated buffers fit within the memory capacity<br>
/// provided.<br>
-// TODO(bondhugula): We currently can't generate copies correctly when stores<br>
+// TODO: We currently can't generate copies correctly when stores<br>
// are strided. Check for strided stores.<br>
struct AffineDataCopyGeneration<br>
: public AffineDataCopyGenerationBase<AffineDataCopyGeneration> {<br>
@@ -75,7 +75,7 @@ struct AffineDataCopyGeneration<br>
/// Generates copies for memref's living in 'slowMemorySpace' into newly created<br>
/// buffers in 'fastMemorySpace', and replaces memory operations to the former<br>
/// by the latter. Only load op's handled for now.<br>
-/// TODO(bondhugula): extend this to store op's.<br>
+/// TODO: extend this to store op's.<br>
std::unique_ptr<OperationPass<FuncOp>> mlir::createAffineDataCopyGenerationPass(<br>
unsigned slowMemorySpace, unsigned fastMemorySpace, unsigned tagMemorySpace,<br>
int minDmaTransferSize, uint64_t fastMemCapacityBytes) {<br>
@@ -113,7 +113,7 @@ AffineDataCopyGeneration::runOnBlock(Block *block,<br>
// operations excluding AffineForOp's) are always assumed to not exhaust<br>
// memory. As a result, this approach is conservative in some cases at the<br>
// moment; we do a check later and report an error with location info.<br>
- // TODO(bondhugula): An 'affine.if' operation is being treated similar to an<br>
+ // TODO: An 'affine.if' operation is being treated similar to an<br>
// operation. 'affine.if''s could have 'affine.for's in them;<br>
// treat them separately.<br>
<br>
<br>
diff --git a/mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp b/mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp<br>
index aaa21104e1fd..e76151fde692 100644<br>
--- a/mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp<br>
+++ b/mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp<br>
@@ -37,8 +37,8 @@ using namespace mlir;<br>
namespace {<br>
<br>
/// Loop invariant code motion (LICM) pass.<br>
-/// TODO(asabne) : The pass is missing zero-trip tests.<br>
-/// TODO(asabne) : Check for the presence of side effects before hoisting.<br>
+/// TODO: The pass is missing zero-trip tests.<br>
+/// TODO: Check for the presence of side effects before hoisting.<br>
/// TODO: This code should be removed once the new LICM pass can handle its<br>
/// uses.<br>
struct LoopInvariantCodeMotion<br>
@@ -62,7 +62,7 @@ areAllOpsInTheBlockListInvariant(Region &blockList, Value indVar,<br>
SmallPtrSetImpl<Operation *> &opsToHoist);<br>
<br>
static bool isMemRefDereferencingOp(Operation &op) {<br>
- // TODO(asabne): Support DMA Ops.<br>
+ // TODO: Support DMA Ops.<br>
return isa<AffineLoadOp, AffineStoreOp>(op);<br>
}<br>
<br>
@@ -81,7 +81,7 @@ bool isOpLoopInvariant(Operation &op, Value indVar,<br>
// 'affine.if'.<br>
return false;<br>
} else if (isa<AffineDmaStartOp, AffineDmaWaitOp>(op)) {<br>
- // TODO(asabne): Support DMA ops.<br>
+ // TODO: Support DMA ops.<br>
return false;<br>
} else if (!isa<ConstantOp>(op)) {<br>
if (isMemRefDereferencingOp(op)) {<br>
<br>
diff --git a/mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp b/mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp<br>
index c411a6a548ff..ddb00bdd8f0e 100644<br>
--- a/mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp<br>
+++ b/mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp<br>
@@ -159,7 +159,7 @@ constructTiledIndexSetHyperRect(MutableArrayRef<AffineForOp> origLoops,<br>
<br>
/// Tiles the specified band of perfectly nested loops creating tile-space loops<br>
/// and intra-tile loops. A band is a contiguous set of loops.<br>
-// TODO(bondhugula): handle non hyper-rectangular spaces.<br>
+// TODO: handle non hyper-rectangular spaces.<br>
LogicalResult<br>
mlir::tilePerfectlyNested(MutableArrayRef<AffineForOp> input,<br>
ArrayRef<unsigned> tileSizes,<br>
@@ -282,7 +282,7 @@ static void adjustToDivisorsOfTripCounts(ArrayRef<AffineForOp> band,<br>
// based on a simple model that looks at the memory footprint and determines<br>
// tile sizes assuming identity accesses / 1:1 tile size proportional footprint<br>
// along each of the dimensions being tiled.<br>
-// TODO(mlir-team): evolve this model. Tile size determination is a large area<br>
+// TODO: evolve this model. Tile size determination is a large area<br>
// to play with in general.<br>
void LoopTiling::getTileSizes(ArrayRef<AffineForOp> band,<br>
SmallVectorImpl<unsigned> *tileSizes) {<br>
@@ -334,7 +334,7 @@ void LoopTiling::getTileSizes(ArrayRef<AffineForOp> band,<br>
}<br>
<br>
// Divide all loops equally in an attempt to reduce footprint.<br>
- // TODO(bondhugula): this is approximate. Ideally, obtain reuse factor /<br>
+ // TODO: this is approximate. Ideally, obtain reuse factor /<br>
// profitability along each dimension and weight tile sizes based on that as<br>
// one possible approach. Or compute a polynomial in tile sizes and solve for<br>
// it.<br>
<br>
diff --git a/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp b/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp<br>
index c47a65683587..1638502508e3 100644<br>
--- a/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp<br>
+++ b/mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp<br>
@@ -236,7 +236,7 @@ using namespace mlir;<br>
///<br>
/// Lowering, unrolling, pipelining:<br>
/// ================================<br>
-/// TODO(ntv): point to the proper places.<br>
+/// TODO: point to the proper places.<br>
///<br>
/// Algorithm:<br>
/// ==========<br>
@@ -248,7 +248,7 @@ using namespace mlir;<br>
/// reduction, vectorizable, ...) as well as b. all contiguous load/store<br>
/// operations along a specified minor dimension (not necessarily the<br>
/// fastest varying) ;<br>
-/// 2. analyzing those patterns for profitability (TODO(ntv): and<br>
+/// 2. analyzing those patterns for profitability (TODO: and<br>
/// interference);<br>
/// 3. Then, for each pattern in order:<br>
/// a. applying iterative rewriting of the loop and the load operations in<br>
@@ -259,7 +259,7 @@ using namespace mlir;<br>
/// c. traversing the use-def chains starting from the roots and iteratively<br>
/// propagating vectorized values. Scalar values that are encountered<br>
/// during this process must come from outside the scope of the current<br>
-/// pattern (TODO(ntv): enforce this and generalize). Such a scalar value<br>
+/// pattern (TODO: enforce this and generalize). Such a scalar value<br>
/// is vectorized only if it is a constant (into a vector splat). The<br>
/// non-constant case is not supported for now and results in the pattern<br>
/// failing to vectorize;<br>
@@ -582,7 +582,7 @@ Vectorize::Vectorize(ArrayRef<int64_t> virtualVectorSize) {<br>
vectorSizes = virtualVectorSize;<br>
}<br>
<br>
-/////// TODO(ntv): Hoist to a VectorizationStrategy.cpp when appropriate.<br>
+/////// TODO: Hoist to a VectorizationStrategy.cpp when appropriate.<br>
/////////<br>
namespace {<br>
<br>
@@ -614,7 +614,7 @@ static void vectorizeLoopIfProfitable(Operation *loop, unsigned depthInPattern,<br>
/// load/store MemRefs, this creates a generic vectorization strategy that works<br>
/// for any loop in a hierarchy (outermost, innermost or intermediate).<br>
///<br>
-/// TODO(ntv): In the future we should additionally increase the power of the<br>
+/// TODO: In the future we should additionally increase the power of the<br>
/// profitability analysis along 3 directions:<br>
/// 1. account for loop extents (both static and parametric + annotations);<br>
/// 2. account for data layout permutations;<br>
@@ -636,7 +636,7 @@ static LogicalResult analyzeProfitability(ArrayRef<NestedMatch> matches,<br>
return success();<br>
}<br>
<br>
-///// end TODO(ntv): Hoist to a VectorizationStrategy.cpp when appropriate /////<br>
+///// end TODO: Hoist to a VectorizationStrategy.cpp when appropriate /////<br>
<br>
namespace {<br>
<br>
@@ -741,7 +741,7 @@ static void computeMemoryOpIndices(Operation *op, AffineMap map,<br>
}<br>
}<br>
<br>
-////// TODO(ntv): Hoist to a VectorizationMaterialize.cpp when appropriate. ////<br>
+////// TODO: Hoist to a VectorizationMaterialize.cpp when appropriate. ////<br>
<br>
/// Handles the vectorization of load and store MLIR operations.<br>
///<br>
@@ -763,7 +763,7 @@ static LogicalResult vectorizeRootOrTerminal(Value iv,<br>
auto memRefType = memoryOp.getMemRef().getType().template cast<MemRefType>();<br>
<br>
auto elementType = memRefType.getElementType();<br>
- // TODO(ntv): ponder whether we want to further vectorize a vector value.<br>
+ // TODO: ponder whether we want to further vectorize a vector value.<br>
assert(VectorType::isValidElementType(elementType) &&<br>
"Not a valid vector element type");<br>
auto vectorType = VectorType::get(state->strategy->vectorSizes, elementType);<br>
@@ -772,7 +772,7 @@ static LogicalResult vectorizeRootOrTerminal(Value iv,<br>
auto *opInst = memoryOp.getOperation();<br>
// For now, vector.transfers must be aligned, operate only on indices with an<br>
// identity subset of AffineMap and do not change layout.<br>
- // TODO(ntv): increase the expressiveness power of vector.transfer operations<br>
+ // TODO: increase the expressiveness power of vector.transfer operations<br>
// as needed by various targets.<br>
if (auto load = dyn_cast<AffineLoadOp>(opInst)) {<br>
OpBuilder b(opInst);<br>
@@ -800,7 +800,7 @@ static LogicalResult vectorizeRootOrTerminal(Value iv,<br>
}<br>
return success();<br>
}<br>
-/// end TODO(ntv): Hoist to a VectorizationMaterialize.cpp when appropriate. ///<br>
+/// end TODO: Hoist to a VectorizationMaterialize.cpp when appropriate. ///<br>
<br>
/// Coarsens the loops bounds and transforms all remaining load and store<br>
/// operations into the appropriate vector.transfer.<br>
@@ -937,7 +937,7 @@ static Value vectorizeConstant(Operation *op, ConstantOp constant, Type type) {<br>
/// Returns an operand that has been vectorized to match `state`'s strategy if<br>
/// vectorization is possible with the above logic. Returns nullptr otherwise.<br>
///<br>
-/// TODO(ntv): handle more complex cases.<br>
+/// TODO: handle more complex cases.<br>
static Value vectorizeOperand(Value operand, Operation *op,<br>
VectorizationState *state) {<br>
LLVM_DEBUG(dbgs() << "\n[early-vect]vectorize operand: " << operand);<br>
@@ -956,7 +956,7 @@ static Value vectorizeOperand(Value operand, Operation *op,<br>
LLVM_DEBUG(dbgs() << "-> delayed replacement by: " << res);<br>
return res;<br>
}<br>
- // 2. TODO(ntv): broadcast needed.<br>
+ // 2. TODO: broadcast needed.<br>
if (operand.getType().isa<VectorType>()) {<br>
LLVM_DEBUG(dbgs() << "-> non-vectorizable");<br>
return nullptr;<br>
@@ -978,7 +978,7 @@ static Value vectorizeOperand(Value operand, Operation *op,<br>
/// particular operation vectorizes. For now we implement the case distinction<br>
/// here.<br>
/// Returns a vectorized form of an operation or nullptr if vectorization fails.<br>
-// TODO(ntv): consider adding a trait to Op to describe how it gets vectorized.<br>
+// TODO: consider adding a trait to Op to describe how it gets vectorized.<br>
// Maybe some Ops are not vectorizable or require some tricky logic, we cannot<br>
// do one-off logic here; ideally it would be TableGen'd.<br>
static Operation *vectorizeOneOperation(Operation *opInst,<br>
@@ -1044,9 +1044,9 @@ static Operation *vectorizeOneOperation(Operation *opInst,<br>
}<br>
<br>
// Create a clone of the op with the proper operands and return types.<br>
- // TODO(ntv): The following assumes there is always an op with a fixed<br>
+ // TODO: The following assumes there is always an op with a fixed<br>
// name that works both in scalar mode and vector mode.<br>
- // TODO(ntv): Is it worth considering an Operation.clone operation which<br>
+ // TODO: Is it worth considering an Operation.clone operation which<br>
// changes the type so we can promote an Operation with less boilerplate?<br>
OpBuilder b(opInst);<br>
OperationState newOp(opInst->getLoc(), opInst->getName().getStringRef(),<br>
@@ -1072,7 +1072,7 @@ static LogicalResult vectorizeNonTerminals(VectorizationState *state) {<br>
// Note: we have to exclude terminals because some of their defs may not be<br>
// nested under the vectorization pattern (e.g. constants defined in an<br>
// encompassing scope).<br>
- // TODO(ntv): Use a backward slice for terminals, avoid special casing and<br>
+ // TODO: Use a backward slice for terminals, avoid special casing and<br>
// merge implementations.<br>
for (auto *op : state->roots) {<br>
getForwardSlice(op, &worklist, [state](Operation *op) {<br>
@@ -1120,7 +1120,7 @@ static LogicalResult vectorizeRootMatch(NestedMatch m,<br>
// pattern matching, from profitability analysis, from application.<br>
// As a consequence we must check that each root pattern is still<br>
// vectorizable. If a pattern is not vectorizable anymore, we just skip it.<br>
- // TODO(ntv): implement a non-greedy profitability analysis that keeps only<br>
+ // TODO: implement a non-greedy profitability analysis that keeps only<br>
// non-intersecting patterns.<br>
if (!isVectorizableLoopBody(loop, vectorTransferPattern())) {<br>
LLVM_DEBUG(dbgs() << "\n[early-vect]+++++ loop is not vectorizable");<br>
@@ -1162,7 +1162,7 @@ static LogicalResult vectorizeRootMatch(NestedMatch m,<br>
<br>
// 2. Vectorize operations reached by use-def chains from root except the<br>
// terminals (store operations) that need to be post-processed separately.<br>
- // TODO(ntv): add more as we expand.<br>
+ // TODO: add more as we expand.<br>
if (failed(vectorizeNonTerminals(&state))) {<br>
LLVM_DEBUG(dbgs() << "\n[early-vect]+++++ failed vectorizeNonTerminals");<br>
return guard.failure();<br>
@@ -1172,7 +1172,7 @@ static LogicalResult vectorizeRootMatch(NestedMatch m,<br>
// Note: we have to post-process terminals because some of their defs may not<br>
// be nested under the vectorization pattern (e.g. constants defined in an<br>
// encompassing scope).<br>
- // TODO(ntv): Use a backward slice for terminals, avoid special casing and<br>
+ // TODO: Use a backward slice for terminals, avoid special casing and<br>
// merge implementations.<br>
for (auto *op : state.terminals) {<br>
if (!vectorizeOneOperation(op, &state)) { // nullptr == failure<br>
@@ -1221,7 +1221,7 @@ void Vectorize::runOnFunction() {<br>
// This automatically prunes intersecting matches.<br>
for (auto m : matches) {<br>
VectorizationStrategy strategy;<br>
- // TODO(ntv): depending on profitability, elect to reduce the vector size.<br>
+ // TODO: depending on profitability, elect to reduce the vector size.<br>
strategy.vectorSizes.assign(vectorSizes.begin(), vectorSizes.end());<br>
if (failed(analyzeProfitability(m.getMatchedChildren(), 1, patternDepth,<br>
&strategy))) {<br>
@@ -1229,10 +1229,10 @@ void Vectorize::runOnFunction() {<br>
}<br>
vectorizeLoopIfProfitable(m.getMatchedOperation(), 0, patternDepth,<br>
&strategy);<br>
- // TODO(ntv): if pattern does not apply, report it; alter the<br>
+ // TODO: if pattern does not apply, report it; alter the<br>
// cost/benefit.<br>
vectorizeRootMatch(m, &strategy);<br>
- // TODO(ntv): some diagnostics if failure to vectorize occurs.<br>
+ // TODO: some diagnostics if failure to vectorize occurs.<br>
}<br>
}<br>
LLVM_DEBUG(dbgs() << "\n");<br>
<br>
diff --git a/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp b/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp<br>
index 13c5ed835c66..fd0c6245e084 100644<br>
--- a/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp<br>
+++ b/mlir/lib/Dialect/GPU/IR/GPUDialect.cpp<br>
@@ -87,7 +87,7 @@ LogicalResult GPUDialect::verifyOperationAttribute(Operation *op,<br>
return launchOp.emitOpError("kernel function is missing the '")<br>
<< GPUDialect::getKernelFuncAttrName() << "' attribute";<br>
<br>
- // TODO(ntv,zinenko,herhut): if the kernel function has been converted to<br>
+ // TODO: if the kernel function has been converted to<br>
// the LLVM dialect but the caller hasn't (which happens during the<br>
// separate compilation), do not check type correspondence as it would<br>
// require the verifier to be aware of the LLVM type conversion.<br>
<br>
diff --git a/mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp b/mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp<br>
index 1ec0f0cf65af..fcae3114188a 100644<br>
--- a/mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp<br>
+++ b/mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp<br>
@@ -156,7 +156,7 @@ static gpu::GPUFuncOp outlineKernelFuncImpl(gpu::LaunchOp launchOp,<br>
map.map(operand.value(), entryBlock.getArgument(operand.index()));<br>
<br>
// Clone the region of the gpu.launch operation into the gpu.func operation.<br>
- // TODO(ravishankarm): If cloneInto can be modified such that if a mapping for<br>
+ // TODO: If cloneInto can be modified such that if a mapping for<br>
// a block exists, that block will be used to clone operations into (at the<br>
// end of the block), instead of creating a new block, this would be much<br>
// cleaner.<br>
<br>
diff --git a/mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp b/mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp<br>
index 85609aa9f052..b42929039a97 100644<br>
--- a/mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp<br>
+++ b/mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp<br>
@@ -80,7 +80,7 @@ MappingLevel &operator++(MappingLevel &mappingLevel) {<br>
/// Computed the hardware id to use for a given mapping level. Will<br>
/// assign x,y and z hardware ids for the first 3 dimensions and use<br>
/// sequential after.<br>
-/// TODO(ravishankarm/herhut) : Make this use x for the inner-most loop that is<br>
+/// TODO: Make this use x for the inner-most loop that is<br>
/// distributed to map to x, the next innermost to y and the next innermost to<br>
/// z.<br>
static gpu::Processor getHardwareIdForMapping(MappingLevel level,<br>
<br>
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp<br>
index 6de98ca89ec1..f448427099a4 100644<br>
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp<br>
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp<br>
@@ -978,7 +978,7 @@ static LogicalResult verify(DialectCastOp op) {<br>
// * if we allow memrefs to cast from/to bare pointers, some users might<br>
// alternatively want metadata that only present in the descriptor.<br>
//<br>
- // TODO(timshen): re-evaluate the memref cast design when it's needed.<br>
+ // TODO: re-evaluate the memref cast design when it's needed.<br>
return op.emitOpError("type must be non-index integer types, float types, "<br>
"or vector of mentioned types.");<br>
};<br>
<br>
diff --git a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp<br>
index dab441fc26ff..9a694a5e9899 100644<br>
--- a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp<br>
+++ b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp<br>
@@ -141,7 +141,7 @@ static LogicalResult verify(MmaOp op) {<br>
// NVVMDialect initialization, type parsing, and registration.<br>
//===----------------------------------------------------------------------===//<br>
<br>
-// TODO(herhut): This should be the llvm.nvvm dialect once this is supported.<br>
+// TODO: This should be the llvm.nvvm dialect once this is supported.<br>
NVVMDialect::NVVMDialect(MLIRContext *context) : Dialect("nvvm", context) {<br>
addOperations<<br>
#define GET_OP_LIST<br>
<br>
diff --git a/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp<br>
index aac1727c6be8..f3771dd57719 100644<br>
--- a/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp<br>
+++ b/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp<br>
@@ -84,7 +84,7 @@ static ParseResult parseROCDLMubufStoreOp(OpAsmParser &parser,<br>
// ROCDLDialect initialization, type parsing, and registration.<br>
//===----------------------------------------------------------------------===//<br>
<br>
-// TODO(herhut): This should be the llvm.rocdl dialect once this is supported.<br>
+// TODO: This should be the llvm.rocdl dialect once this is supported.<br>
ROCDLDialect::ROCDLDialect(MLIRContext *context) : Dialect("rocdl", context) {<br>
addOperations<<br>
#define GET_OP_LIST<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp b/mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp<br>
index 4c218503ba17..af15740af2a8 100644<br>
--- a/mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp<br>
@@ -223,7 +223,7 @@ LinalgDependenceGraph::findOperationsWithCoveringDependences(<br>
SmallVector<Operation *, 8> res;<br>
// Consider an intermediate interleaved `interim` op, look for any dependence<br>
// to an aliasing view on a src -> op -> dst path.<br>
- // TODO(ntv) we are not considering paths yet, just interleaved positions.<br>
+ // TODO: we are not considering paths yet, just interleaved positions.<br>
for (auto dt : types) {<br>
for (auto dependence : getDependencesFrom(src, dt)) {<br>
auto interimPos = linalgOpPositions.lookup(dependence.dependentOpView.op);<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/EDSC/Builders.cpp b/mlir/lib/Dialect/Linalg/EDSC/Builders.cpp<br>
index 8cfc25d2ff8e..b9ec01d3ec79 100644<br>
--- a/mlir/lib/Dialect/Linalg/EDSC/Builders.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/EDSC/Builders.cpp<br>
@@ -226,7 +226,7 @@ Operation *mlir::edsc::ops::linalg_generic_conv_nhwc(Value vI, Value vW,<br>
ArrayRef<int> strides,<br>
ArrayRef<int> dilations) {<br>
MLIRContext *ctx = ScopedContext::getContext();<br>
- // TODO(ntv) some template magic to make everything rank-polymorphic.<br>
+ // TODO: some template magic to make everything rank-polymorphic.<br>
assert((dilations.empty() || dilations.size() == 2) && "only 2-D conv atm");<br>
assert((strides.empty() || strides.size() == 2) && "only 2-D conv atm");<br>
<br>
@@ -259,7 +259,7 @@ Operation *mlir::edsc::ops::linalg_generic_dilated_conv_nhwc(<br>
Value vI, Value vW, Value vO, int depth_multiplier, ArrayRef<int> strides,<br>
ArrayRef<int> dilations) {<br>
MLIRContext *ctx = ScopedContext::getContext();<br>
- // TODO(ntv) some template magic to make everything rank-polymorphic.<br>
+ // TODO: some template magic to make everything rank-polymorphic.<br>
assert((dilations.empty() || dilations.size() == 2) && "only 2-D conv atm");<br>
assert((strides.empty() || strides.size() == 2) && "only 2-D conv atm");<br>
<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp b/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp<br>
index 8012a1087ee1..18ea31571aa4 100644<br>
--- a/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp<br>
@@ -447,7 +447,7 @@ static bool isReshapableDimBand(unsigned dim, unsigned extent,<br>
// proper symbol in the AffineExpr of a stride.<br>
if (ShapedType::isDynamic(sizes[dim + 1]))<br>
return false;<br>
- // TODO(ntv) Refine this by passing the proper nDims and nSymbols so we can<br>
+ // TODO: Refine this by passing the proper nDims and nSymbols so we can<br>
// simplify on the fly and catch more reshapable cases.<br>
if (strides[idx] != strides[idx + 1] * sizes[idx + 1])<br>
return false;<br>
@@ -520,7 +520,7 @@ computeReshapeCollapsedType(MemRefType type,<br>
<br>
/// Helper functions assert Attribute of the proper type in attr and returns the<br>
/// corresponding vector.<br>
-/// TODO(rridle,ntv) this should be evolved into a generic<br>
+/// TODO: this should be evolved into a generic<br>
/// `getRangeOfType<AffineMap>(ArrayAttr attrs)` that does not copy.<br>
static SmallVector<AffineMap, 4> getAffineMaps(ArrayAttr attrs) {<br>
return llvm::to_vector<8>(llvm::map_range(<br>
@@ -713,7 +713,7 @@ static LogicalResult verify(TensorReshapeOp op) {<br>
if (failed(verifyReshapeLikeTypes(op, expandedType, collapsedType)))<br>
return failure();<br>
auto maps = getAffineMaps(op.reassociation());<br>
- // TODO(ntv): expanding a ? with a non-constant is under-specified. Error<br>
+ // TODO: expanding a ? with a non-constant is under-specified. Error<br>
// out.<br>
RankedTensorType expectedType =<br>
computeTensorReshapeCollapsedType(expandedType, maps);<br>
@@ -744,7 +744,7 @@ void mlir::linalg::SliceOp::build(OpBuilder &b, OperationState &result,<br>
(void)res;<br>
<br>
unsigned rank = memRefType.getRank();<br>
- // TODO(ntv): propagate static size and stride information when available.<br>
+ // TODO: propagate static size and stride information when available.<br>
SmallVector<int64_t, 4> sizes(rank, -1); // -1 encodes dynamic size.<br>
result.addTypes({MemRefType::Builder(memRefType)<br>
.setShape(sizes)<br>
@@ -1075,7 +1075,7 @@ mlir::linalg::weightedPoolingInputIndex(PoolingOp op,<br>
SmallVector<AffineExpr, 4> res;<br>
res.reserve(outputDims.size());<br>
for (unsigned i = 0, e = outputDims.size(); i < e; ++i) {<br>
- // TODO(ntv): add a level of indirection to linalg.generic.<br>
+ // TODO: add a level of indirection to linalg.generic.<br>
auto expr = op.getStride(i) * outputDims[i] +<br>
op.getDilation(i) * windowDims[i] - op.getLowPad(i);<br>
res.push_back(expr);<br>
@@ -1137,7 +1137,7 @@ std::string mlir::linalg::generateLibraryCallName(Operation *op) {<br>
return ss.str();<br>
}<br>
<br>
-// TODO(ntv, rriddle): Consider making all this boilerplate easy to autogenerate<br>
+// TODO: Consider making all this boilerplate easy to autogenerate<br>
// with Tablegen. This seems a desirable property in the context of OpInterfaces<br>
// where a Linalg "named" op **isa** LinalgOp.<br>
LogicalResult ConvOp::fold(ArrayRef<Attribute>,<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp b/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp<br>
index e37146e73954..d67126c21f3e 100644<br>
--- a/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp<br>
@@ -279,12 +279,12 @@ bool mlir::linalg::isFusableInto(const LinalgDependenceGraph &graph,<br>
return false;<br>
}<br>
if (auto convOp = dyn_cast<linalg::ConvOp>(producer.getOperation())) {<br>
- // TODO(ntv): add a level of indirection to linalg.generic.<br>
+ // TODO: add a level of indirection to linalg.generic.<br>
if (convOp.padding())<br>
return false;<br>
}<br>
if (auto convOp = dyn_cast<linalg::ConvOp>(consumer.getOperation())) {<br>
- // TODO(ntv): add a level of indirection to linalg.generic.<br>
+ // TODO: add a level of indirection to linalg.generic.<br>
if (convOp.padding())<br>
return false;<br>
}<br>
@@ -403,7 +403,7 @@ static void fuseLinalgOpsGreedily(FuncOp f) {<br>
linalgOps.push_back(op);<br>
});<br>
<br>
- // TODO(pifon, ntv): LinalgDependenceGraph should be able to update itself.<br>
+ // TODO: LinalgDependenceGraph should be able to update itself.<br>
// The current naive and expensive reconstruction of the graph should be<br>
// removed.<br>
for (auto *op : llvm::reverse(linalgOps)) {<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Loops.cpp b/mlir/lib/Dialect/Linalg/Transforms/Loops.cpp<br>
index 575115c0fbed..6cbe947657a0 100644<br>
--- a/mlir/lib/Dialect/Linalg/Transforms/Loops.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/Transforms/Loops.cpp<br>
@@ -165,7 +165,7 @@ void emitScalarImplementation(ArrayRef<Value> allIvs,<br>
SmallVector<Value, 4> indexedValues;<br>
indexedValues.reserve(nInputs + nOutputs);<br>
<br>
- // TODO(mravishankar): Avoid the loads if the corresponding argument of the<br>
+ // TODO: Avoid the loads if the corresponding argument of the<br>
// region has no uses.<br>
// 1.a. Emit load from input views.<br>
for (unsigned i = 0; i < nInputs; ++i) {<br>
@@ -183,7 +183,7 @@ void emitScalarImplementation(ArrayRef<Value> allIvs,<br>
IndexedValueType(linalgOp.getOutputBuffer(i))(indexing));<br>
}<br>
<br>
- // TODO(ntv): When a region inliner exists, use it.<br>
+ // TODO: When a region inliner exists, use it.<br>
// 2. Inline region, currently only works for a single basic block.<br>
// 3. Emit store.<br>
SmallVector<SmallVector<Value, 8>, 8> indexing;<br>
@@ -246,7 +246,7 @@ void emitScalarImplementation(ArrayRef<Value> allIvs, DotOp dotOp) {<br>
template <typename IndexedValueType><br>
Value getConvOpInput(ConvOp convOp, StdIndexedValue im,<br>
MutableArrayRef<Value> imIdx) {<br>
- // TODO(ntv): add a level of indirection to linalg.generic.<br>
+ // TODO: add a level of indirection to linalg.generic.<br>
if (!convOp.padding())<br>
return im(imIdx);<br>
<br>
@@ -409,7 +409,7 @@ static void emitScalarImplementation(ArrayRef<Value> allIvs,<br>
for (unsigned i = 0; i < nLoops; ++i)<br>
indexedValues.push_back(allIvs[i]);<br>
<br>
- // TODO(mravishankar): Avoid the loads if the corresponding argument of the<br>
+ // TODO: Avoid the loads if the corresponding argument of the<br>
// region has no uses.<br>
// 1.a. Emit load from input views.<br>
for (unsigned i = 0; i < nInputs; ++i) {<br>
@@ -428,7 +428,7 @@ static void emitScalarImplementation(ArrayRef<Value> allIvs,<br>
IndexedValueType(indexedGenericOp.getOutputBuffer(i))(indexing));<br>
}<br>
<br>
- // TODO(ntv): When a region inliner exists, use it.<br>
+ // TODO: When a region inliner exists, use it.<br>
// 2. Inline region, currently only works for a single basic block.<br>
// 3. Emit store.<br>
SmallVector<SmallVector<Value, 8>, 8> indexing;<br>
@@ -560,7 +560,7 @@ static void lowerLinalgToLoopsImpl(FuncOp funcOp, MLIRContext *context) {<br>
OwningRewritePatternList patterns;<br>
// Canonicalization and folding patterns applied greedily allow cleaning up<br>
// the emitted IR on the fly.<br>
- // TODO(ntv) fold view and subview ops?<br>
+ // TODO: fold view and subview ops?<br>
insertPatterns<LoopType,<br>
#define GET_OP_LIST<br>
#include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp b/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp<br>
index aebc33ab541d..a5323f4b7687 100644<br>
--- a/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp<br>
@@ -316,7 +316,7 @@ promoteSubViews(OpBuilder &b, LinalgOp op,<br>
assert(op.hasBufferSemantics() && "expected linalg op with buffer semantics");<br>
<br>
if (auto convOp = dyn_cast<linalg::ConvOp>(op.getOperation())) {<br>
- // TODO(ntv): add a level of indirection to linalg.generic.<br>
+ // TODO: add a level of indirection to linalg.generic.<br>
if (convOp.padding())<br>
return {};<br>
}<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp b/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp<br>
index bde163e3ee72..6ffc181fed67 100644<br>
--- a/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp<br>
@@ -161,7 +161,7 @@ struct TileCheck : public AffineExprVisitor<TileCheck> {<br>
// }<br>
// }<br>
//<br>
-// TODO(pifon, ntv): Investigate whether mixing implicit and explicit indices<br>
+// TODO: Investigate whether mixing implicit and explicit indices<br>
// does not lead to losing information.<br>
static void transformIndexedGenericOpIndices(<br>
OpBuilder &b, LinalgOp op, SmallVectorImpl<Value> &ivs,<br>
@@ -176,7 +176,7 @@ static void transformIndexedGenericOpIndices(<br>
// that refers to an existing function symbol. The `fun` function call will be<br>
// inserted in the loop body in that case.<br>
//<br>
- // TODO(pifon): Add support for `linalg.indexed_generic` with `fun` attribute.<br>
+ // TODO: Add support for `linalg.indexed_generic` with `fun` attribute.<br>
auto ®ion = indexedGenericOp.region();<br>
if (region.empty()) {<br>
indexedGenericOp.emitOpError("expected a region");<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp b/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp<br>
index 07de4952d928..bba7b2a10030 100644<br>
--- a/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp<br>
@@ -83,7 +83,7 @@ LogicalResult mlir::linalg::vectorizeLinalgOpPrecondition(Operation *op) {<br>
if (!genericOp || !::isRowMajorMatmul(genericOp))<br>
return failure();<br>
<br>
- // TODO(ntv): non-identity layout.<br>
+ // TODO: non-identity layout.<br>
auto isStaticMemRefWithIdentityLayout = [](Value v) {<br>
auto m = v.getType().dyn_cast<MemRefType>();<br>
if (!m || !m.hasStaticShape() || !m.getAffineMaps().empty())<br>
<br>
diff --git a/mlir/lib/Dialect/Linalg/Utils/Utils.cpp b/mlir/lib/Dialect/Linalg/Utils/Utils.cpp<br>
index 5bba11420d08..a9d5e2028c22 100644<br>
--- a/mlir/lib/Dialect/Linalg/Utils/Utils.cpp<br>
+++ b/mlir/lib/Dialect/Linalg/Utils/Utils.cpp<br>
@@ -181,7 +181,7 @@ void GenerateLoopNest<AffineForOp>::doit(<br>
/// of the innermost loop is populated by `bodyBuilderFn` that accepts a range<br>
/// of induction variables for all loops. `ivStorage` is used to store the<br>
/// partial list of induction variables.<br>
-// TODO(zinenko,ntv): this function can be made iterative instead. However, it<br>
+// TODO: this function can be made iterative instead. However, it<br>
// will have at most as many recursive calls as nested loops, which rarely<br>
// exceeds 10.<br>
static void<br>
<br>
diff --git a/mlir/lib/Dialect/Quant/Utils/FakeQuantSupport.cpp b/mlir/lib/Dialect/Quant/Utils/FakeQuantSupport.cpp<br>
index 71b7e042aa1a..37b72af93424 100644<br>
--- a/mlir/lib/Dialect/Quant/Utils/FakeQuantSupport.cpp<br>
+++ b/mlir/lib/Dialect/Quant/Utils/FakeQuantSupport.cpp<br>
@@ -61,7 +61,7 @@ static bool getDefaultStorageParams(unsigned numBits, bool narrowRange,<br>
// point is derived from the shifted range, and the scale isn't changed. As<br>
// a consequence some values, which are supposed in the original [rmin, rmax]<br>
// range will be outside the shifted range and be clamped during quantization.<br>
-// TODO(fengliuai): we should nudge the scale as well, but that requires the<br>
+// TODO: we should nudge the scale as well, but that requires the<br>
// fake quant op used in the training to use the nudged scale as well.<br>
static void getNudgedScaleAndZeroPoint(int64_t qmin, int64_t qmax, double rmin,<br>
double rmax, double &scale,<br>
<br>
diff --git a/mlir/lib/Dialect/Quant/Utils/QuantizeUtils.cpp b/mlir/lib/Dialect/Quant/Utils/QuantizeUtils.cpp<br>
index 1fbc60962fd1..7b475d31914b 100644<br>
--- a/mlir/lib/Dialect/Quant/Utils/QuantizeUtils.cpp<br>
+++ b/mlir/lib/Dialect/Quant/Utils/QuantizeUtils.cpp<br>
@@ -137,7 +137,7 @@ Attribute mlir::quant::quantizeAttr(Attribute realValue,<br>
quantizedElementType.dyn_cast<UniformQuantizedPerAxisType>()) {<br>
UniformQuantizedPerAxisValueConverter converter(uniformQuantizedPerAxis);<br>
auto converted = converter.convert(realValue);<br>
- // TODO(fengliuai): why we need this outConvertedType? remove it?<br>
+ // TODO: why we need this outConvertedType? remove it?<br>
if (converted) {<br>
outConvertedType = converted.getType();<br>
}<br>
<br>
diff --git a/mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp b/mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp<br>
index 991d7c179f90..a79ef0023a7f 100644<br>
--- a/mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp<br>
+++ b/mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp<br>
@@ -68,7 +68,7 @@ UniformQuantizedPerAxisValueConverter::convert(Attribute realValue) {<br>
if (auto attr = realValue.dyn_cast<DenseFPElementsAttr>()) {<br>
return convert(attr);<br>
}<br>
- // TODO(fengliuai): handles sparse elements attribute<br>
+ // TODO: handles sparse elements attribute<br>
return nullptr;<br>
}<br>
<br>
<br>
diff --git a/mlir/lib/Dialect/SDBM/SDBM.cpp b/mlir/lib/Dialect/SDBM/SDBM.cpp<br>
index 77f81fed0322..df24e77bc4f2 100644<br>
--- a/mlir/lib/Dialect/SDBM/SDBM.cpp<br>
+++ b/mlir/lib/Dialect/SDBM/SDBM.cpp<br>
@@ -187,7 +187,7 @@ struct SDBMBuilder : public SDBMVisitor<SDBMBuilder, SDBMBuilderResult> {<br>
SDBM SDBM::get(ArrayRef<SDBMExpr> inequalities, ArrayRef<SDBMExpr> equalities) {<br>
SDBM result;<br>
<br>
- // TODO(zinenko): consider detecting equalities in the list of inequalities.<br>
+ // TODO: consider detecting equalities in the list of inequalities.<br>
// This is potentially expensive and requires to<br>
// - create a list of negated inequalities (may allocate under lock);<br>
// - perform a pairwise comparison of direct and negated inequalities;<br>
@@ -289,7 +289,7 @@ SDBM SDBM::get(ArrayRef<SDBMExpr> inequalities, ArrayRef<SDBMExpr> equalities) {<br>
// value is positive, the set defined by SDBM is trivially empty. We store<br>
// this value anyway and continue processing to maintain the correspondence<br>
// between the matrix form and the list-of-SDBMExpr form.<br>
- // TODO(zinenko): we may want to reconsider this once we have canonicalization<br>
+ // TODO: we may want to reconsider this once we have canonicalization<br>
// or simplification in place<br>
auto updateMatrix = [](SDBM &sdbm, const SDBMBuilderResult &r) {<br>
for (auto positivePos : r.positivePos) {<br>
<br>
diff --git a/mlir/lib/Dialect/SDBM/SDBMExpr.cpp b/mlir/lib/Dialect/SDBM/SDBMExpr.cpp<br>
index 0428df79a053..5d60158c34e4 100644<br>
--- a/mlir/lib/Dialect/SDBM/SDBMExpr.cpp<br>
+++ b/mlir/lib/Dialect/SDBM/SDBMExpr.cpp<br>
@@ -451,7 +451,7 @@ Optional<SDBMExpr> SDBMExpr::tryConvertAffineExpr(AffineExpr affine) {<br>
if (pattern.match(expr)) {<br>
if (SDBMExpr converted = visit(x.matched())) {<br>
if (auto varConverted = converted.dyn_cast<SDBMTermExpr>())<br>
- // TODO(ntv): return varConverted.stripe(C.getConstantValue());<br>
+ // TODO: return varConverted.stripe(C.getConstantValue());<br>
return SDBMStripeExpr::get(<br>
varConverted,<br>
SDBMConstantExpr::get(dialect,<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp b/mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp<br>
index 894de3dba377..fbc644d38ae3 100644<br>
--- a/mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp<br>
@@ -69,11 +69,11 @@ struct SPIRVInlinerInterface : public DialectInlinerInterface {<br>
/// operation registered to the current dialect.<br>
bool isLegalToInline(Operation *op, Region *dest,<br>
BlockAndValueMapping &) const final {<br>
- // TODO(antiagainst): Enable inlining structured control flows with return.<br>
+ // TODO: Enable inlining structured control flows with return.<br>
if ((isa<spirv::SelectionOp, spirv::LoopOp>(op)) &&<br>
containsReturn(op->getRegion(0)))<br>
return false;<br>
- // TODO(antiagainst): we need to filter OpKill here to avoid inlining it to<br>
+ // TODO: we need to filter OpKill here to avoid inlining it to<br>
// a loop continue construct:<br>
// <a href="https://github.com/KhronosGroup/SPIRV-Headers/issues/86" rel="noreferrer" target="_blank">https://github.com/KhronosGroup/SPIRV-Headers/issues/86</a><br>
// However OpKill is fragment shader specific and we don't support it yet.<br>
@@ -330,7 +330,7 @@ static Type parseCooperativeMatrixType(SPIRVDialect const &dialect,<br>
return CooperativeMatrixNVType::get(elementTy, scope, dims[0], dims[1]);<br>
}<br>
<br>
-// TODO(ravishankarm) : Reorder methods to be utilities first and parse*Type<br>
+// TODO: Reorder methods to be utilities first and parse*Type<br>
// methods in alphabetical order<br>
//<br>
// storage-class ::= `UniformConstant`<br>
@@ -438,7 +438,7 @@ static Optional<ValTy> parseAndVerify(SPIRVDialect const &dialect,<br>
template <><br>
Optional<Type> parseAndVerify<Type>(SPIRVDialect const &dialect,<br>
DialectAsmParser &parser) {<br>
- // TODO(ravishankarm): Further verify that the element type can be sampled<br>
+ // TODO: Further verify that the element type can be sampled<br>
auto ty = parseAndVerifyType(dialect, parser);<br>
if (!ty)<br>
return llvm::None;<br>
@@ -1054,7 +1054,7 @@ LogicalResult SPIRVDialect::verifyOperationAttribute(Operation *op,<br>
StringRef symbol = attribute.first.strref();<br>
Attribute attr = attribute.second;<br>
<br>
- // TODO(antiagainst): figure out a way to generate the description from the<br>
+ // TODO: figure out a way to generate the description from the<br>
// StructAttr definition.<br>
if (symbol == spirv::getEntryPointABIAttrName()) {<br>
if (!attr.isa<spirv::EntryPointABIAttr>())<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp b/mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp<br>
index 6bb07b28d022..d31f9c28362a 100644<br>
--- a/mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp<br>
@@ -89,7 +89,7 @@ static LogicalResult checkCapabilityRequirements(<br>
Type SPIRVTypeConverter::getIndexType(MLIRContext *context) {<br>
// Convert to 32-bit integers for now. Might need a way to control this in<br>
// future.<br>
- // TODO(ravishankarm): It is probably better to make it 64-bit integers. To<br>
+ // TODO: It is probably better to make it 64-bit integers. To<br>
// this some support is needed in SPIR-V dialect for Conversion<br>
// instructions. The Vulkan spec requires the builtins like<br>
// GlobalInvocationID, etc. to be 32-bit (unsigned) integers which should be<br>
@@ -104,7 +104,7 @@ Type SPIRVTypeConverter::getIndexType(MLIRContext *context) {<br>
/// behind the number assignments; we try to follow NVVM conventions and largely<br>
/// give common storage classes a smaller number. The hope is use symbolic<br>
/// memory space representation eventually after memref supports it.<br>
-// TODO(antiagainst): swap Generic and StorageBuffer assignment to be more akin<br>
+// TODO: swap Generic and StorageBuffer assignment to be more akin<br>
// to NVVM.<br>
#define STORAGE_SPACE_MAP_LIST(MAP_FN) \<br>
MAP_FN(spirv::StorageClass::Generic, 1) \<br>
@@ -155,7 +155,7 @@ SPIRVTypeConverter::getStorageClassForMemorySpace(unsigned space) {<br>
<br>
#undef STORAGE_SPACE_MAP_LIST<br>
<br>
-// TODO(ravishankarm): This is a utility function that should probably be<br>
+// TODO: This is a utility function that should probably be<br>
// exposed by the SPIR-V dialect. Keeping it local till the use case arises.<br>
static Optional<int64_t> getTypeNumBytes(Type t) {<br>
if (t.isa<spirv::ScalarType>()) {<br>
@@ -239,7 +239,7 @@ convertScalarType(const spirv::TargetEnv &targetEnv, spirv::ScalarType type,<br>
<br>
// Otherwise we need to adjust the type, which really means adjusting the<br>
// bitwidth given this is a scalar type.<br>
- // TODO(antiagainst): We are unconditionally converting the bitwidth here,<br>
+ // TODO: We are unconditionally converting the bitwidth here,<br>
// this might be okay for non-interface types (i.e., types used in<br>
// Private/Function storage classes), but not for interface types (i.e.,<br>
// types used in StorageBuffer/Uniform/PushConstant/etc. storage classes).<br>
@@ -263,7 +263,7 @@ static Optional<Type><br>
convertVectorType(const spirv::TargetEnv &targetEnv, VectorType type,<br>
Optional<spirv::StorageClass> storageClass = {}) {<br>
if (!spirv::CompositeType::isValid(type)) {<br>
- // TODO(antiagainst): One-element vector types can be translated into scalar<br>
+ // TODO: One-element vector types can be translated into scalar<br>
// types. Vector types with more than four elements can be translated into<br>
// array types.<br>
LLVM_DEBUG(llvm::dbgs()<br>
@@ -297,7 +297,7 @@ convertVectorType(const spirv::TargetEnv &targetEnv, VectorType type,<br>
/// manipulate, like what we do for vectors.<br>
static Optional<Type> convertTensorType(const spirv::TargetEnv &targetEnv,<br>
TensorType type) {<br>
- // TODO(ravishankarm) : Handle dynamic shapes.<br>
+ // TODO: Handle dynamic shapes.<br>
if (!type.hasStaticShape()) {<br>
LLVM_DEBUG(llvm::dbgs()<br>
<< type << " illegal: dynamic shape unimplemented\n");<br>
@@ -406,7 +406,7 @@ SPIRVTypeConverter::SPIRVTypeConverter(spirv::TargetEnvAttr targetAttr)<br>
// adopted in the SPIR-V dialect (i.e., IntegerType, FloatType, VectorType)<br>
// were tried before.<br>
//<br>
- // TODO(antiagainst): this assumes that the SPIR-V types are valid to use in<br>
+ // TODO: this assumes that the SPIR-V types are valid to use in<br>
// the given target environment, which should be the case if the whole<br>
// pipeline is driven by the same target environment. Still, we probably still<br>
// want to validate and convert to be safe.<br>
@@ -462,7 +462,7 @@ LogicalResult<br>
FuncOpConversion::matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,<br>
ConversionPatternRewriter &rewriter) const {<br>
auto fnType = funcOp.getType();<br>
- // TODO(antiagainst): support converting functions with one result.<br>
+ // TODO: support converting functions with one result.<br>
if (fnType.getNumResults())<br>
return failure();<br>
<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/SPIRVOps.cpp b/mlir/lib/Dialect/SPIRV/SPIRVOps.cpp<br>
index 1ac6a1e6d75b..32d13e6afd61 100644<br>
--- a/mlir/lib/Dialect/SPIRV/SPIRVOps.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/SPIRVOps.cpp<br>
@@ -27,7 +27,7 @@<br>
<br>
using namespace mlir;<br>
<br>
-// TODO(antiagainst): generate these strings using ODS.<br>
+// TODO: generate these strings using ODS.<br>
static constexpr const char kAlignmentAttrName[] = "alignment";<br>
static constexpr const char kBranchWeightAttrName[] = "branch_weights";<br>
static constexpr const char kCallee[] = "callee";<br>
@@ -313,7 +313,7 @@ static LogicalResult verifyLoadStorePtrAndValTypes(LoadStoreOpTy op, Value ptr,<br>
// ODS already checks ptr is spirv::PointerType. Just check that the pointee<br>
// type of the pointer and the type of the value are the same<br>
//<br>
- // TODO(ravishankarm): Check that the value type satisfies restrictions of<br>
+ // TODO: Check that the value type satisfies restrictions of<br>
// SPIR-V OpLoad/OpStore operations<br>
if (val.getType() !=<br>
ptr.getType().cast<spirv::PointerType>().getPointeeType()) {<br>
@@ -618,7 +618,7 @@ static LogicalResult verifyGroupNonUniformArithmeticOp(Operation *groupOp) {<br>
Operation *sizeOp = groupOp->getOperand(1).getDefiningOp();<br>
int32_t clusterSize = 0;<br>
<br>
- // TODO(antiagainst): support specialization constant here.<br>
+ // TODO: support specialization constant here.<br>
if (failed(extractValueFromConstOp(sizeOp, clusterSize)))<br>
return groupOp->emitOpError(<br>
"cluster size operand must come from a constant op");<br>
@@ -753,7 +753,7 @@ static Type getElementPtrType(Type type, ValueRange indices, Location baseLoc) {<br>
return nullptr;<br>
}<br>
<br>
- // TODO(denis0x0D): this should be relaxed to allow<br>
+ // TODO: this should be relaxed to allow<br>
// integer literals of other bitwidths.<br>
if (failed(extractValueFromConstOp(op, index))) {<br>
emitError(baseLoc,<br>
@@ -948,7 +948,7 @@ static LogicalResult verify(spirv::AtomicCompareExchangeWeakOp atomOp) {<br>
"as the op result type, but found ")<br>
<< pointeeType << " vs " << atomOp.getType();<br>
<br>
- // TODO(antiagainst): Unequal cannot be set to Release or Acquire and Release.<br>
+ // TODO: Unequal cannot be set to Release or Acquire and Release.<br>
// In addition, Unequal cannot be set to a stronger memory-order then Equal.<br>
<br>
return success();<br>
@@ -1384,7 +1384,7 @@ bool spirv::ConstantOp::isBuildableWith(Type type) {<br>
<br>
if (type.getKind() >= Type::FIRST_SPIRV_TYPE &&<br>
type.getKind() <= spirv::TypeKind::LAST_SPIRV_TYPE) {<br>
- // TODO(antiagainst): support constant struct<br>
+ // TODO: support constant struct<br>
return type.isa<spirv::ArrayType>();<br>
}<br>
<br>
@@ -1633,7 +1633,7 @@ LogicalResult spirv::FuncOp::verifyBody() {<br>
return WalkResult::advance();<br>
});<br>
<br>
- // TODO(antiagainst): verify other bits like linkage type.<br>
+ // TODO: verify other bits like linkage type.<br>
<br>
return failure(walkResult.wasInterrupted());<br>
}<br>
@@ -1939,7 +1939,7 @@ void spirv::LoopOp::build(OpBuilder &builder, OperationState &state) {<br>
}<br>
<br>
static ParseResult parseLoopOp(OpAsmParser &parser, OperationState &state) {<br>
- // TODO(antiagainst): support loop control properly<br>
+ // TODO: support loop control properly<br>
Builder builder = parser.getBuilder();<br>
state.addAttribute("loop_control",<br>
builder.getI32IntegerAttr(<br>
@@ -2222,7 +2222,7 @@ static LogicalResult verify(spirv::ModuleOp moduleOp) {<br>
if (funcOp.isExternal())<br>
return op.emitError("'spv.module' cannot contain external functions");<br>
<br>
- // TODO(antiagainst): move this check to spv.func.<br>
+ // TODO: move this check to spv.func.<br>
for (auto &block : funcOp)<br>
for (auto &op : block) {<br>
if (op.getDialect() != dialect)<br>
@@ -2302,7 +2302,7 @@ static LogicalResult verify(spirv::SelectOp op) {<br>
<br>
static ParseResult parseSelectionOp(OpAsmParser &parser,<br>
OperationState &state) {<br>
- // TODO(antiagainst): support selection control properly<br>
+ // TODO: support selection control properly<br>
Builder builder = parser.getBuilder();<br>
state.addAttribute("selection_control",<br>
builder.getI32IntegerAttr(<br>
@@ -2536,7 +2536,7 @@ static LogicalResult verify(spirv::UnreachableOp unreachableOp) {<br>
if (block->hasNoPredecessors())<br>
return success();<br>
<br>
- // TODO(antiagainst): further verification needs to analyze reachability from<br>
+ // TODO: further verification needs to analyze reachability from<br>
// the entry block.<br>
<br>
return success();<br>
@@ -2626,7 +2626,7 @@ static LogicalResult verify(spirv::VariableOp varOp) {<br>
"constant or spv.globalVariable op");<br>
}<br>
<br>
- // TODO(antiagainst): generate these strings using ODS.<br>
+ // TODO: generate these strings using ODS.<br>
auto *op = varOp.getOperation();<br>
auto descriptorSetName = llvm::convertToSnakeFromCamelCase(<br>
stringifyDecoration(spirv::Decoration::DescriptorSet));<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp b/mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp<br>
index 03ce62807a8b..b0396bfc1163 100644<br>
--- a/mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp<br>
@@ -86,7 +86,7 @@ spirv::getRecursiveImpliedCapabilities(Capability cap) {<br>
llvm::SetVector<Capability, SmallVector<Capability, 0>> allCaps(<br>
directCaps.begin(), directCaps.end());<br>
<br>
- // TODO(antiagainst): This is insufficient; find a better way to handle this<br>
+ // TODO: This is insufficient; find a better way to handle this<br>
// (e.g., using static lists) if this turns out to be a bottleneck.<br>
for (unsigned i = 0; i < allCaps.size(); ++i)<br>
for (Capability c : getDirectImpliedCapabilities(allCaps[i]))<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp b/mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp<br>
index 215c5ba373a4..b5fef1477870 100644<br>
--- a/mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp<br>
@@ -91,7 +91,7 @@ using BlockMergeInfoMap = DenseMap<Block *, BlockMergeInfo>;<br>
/// higher-order bits. So this deserializer uses that to get instruction<br>
/// boundary and parse instructions and build a SPIR-V ModuleOp gradually.<br>
///<br>
-// TODO(antiagainst): clean up created ops on errors<br>
+// TODO: clean up created ops on errors<br>
class Deserializer {<br>
public:<br>
/// Creates a deserializer for the given SPIR-V `binary` module.<br>
@@ -420,7 +420,7 @@ class Deserializer {<br>
/// MLIRContext to create SPIR-V ModuleOp into.<br>
MLIRContext *context;<br>
<br>
- // TODO(antiagainst): create Location subclass for binary blob<br>
+ // TODO: create Location subclass for binary blob<br>
Location unknownLoc;<br>
<br>
/// The SPIR-V ModuleOp.<br>
@@ -602,7 +602,7 @@ LogicalResult Deserializer::processHeader() {<br>
<< majorVersion;<br>
}<br>
<br>
- // TODO(antiagainst): generator number, bound, schema<br>
+ // TODO: generator number, bound, schema<br>
curOffset = spirv::kHeaderWordCount;<br>
return success();<br>
}<br>
@@ -676,7 +676,7 @@ LogicalResult Deserializer::processMemoryModel(ArrayRef<uint32_t> operands) {<br>
}<br>
<br>
LogicalResult Deserializer::processDecoration(ArrayRef<uint32_t> words) {<br>
- // TODO : This function should also be auto-generated. For now, since only a<br>
+ // TODO: This function should also be auto-generated. For now, since only a<br>
// few decorations are processed/handled in a meaningful manner, going with a<br>
// manual implementation.<br>
if (words.size() < 2) {<br>
@@ -804,7 +804,7 @@ LogicalResult Deserializer::processFunction(ArrayRef<uint32_t> operands) {<br>
return emitError(unknownLoc, "unknown Function Control: ") << operands[2];<br>
}<br>
if (functionControl.getValue() != spirv::FunctionControl::None) {<br>
- /// TODO : Handle <br>
diff erent function controls<br>
+ /// TODO: Handle <br>
diff erent function controls<br>
return emitError(unknownLoc, "unhandled Function Control: '")<br>
<< spirv::stringifyFunctionControl(functionControl.getValue())<br>
<< "'";<br>
@@ -1197,7 +1197,7 @@ LogicalResult Deserializer::processArrayType(ArrayRef<uint32_t> operands) {<br>
}<br>
<br>
unsigned count = 0;<br>
- // TODO(antiagainst): The count can also come frome a specialization constant.<br>
+ // TODO: The count can also come frome a specialization constant.<br>
auto countInfo = getConstant(operands[2]);<br>
if (!countInfo) {<br>
return emitError(unknownLoc, "OpTypeArray count <id> ")<br>
@@ -1336,7 +1336,7 @@ LogicalResult Deserializer::processStructType(ArrayRef<uint32_t> operands) {<br>
}<br>
typeMap[operands[0]] =<br>
spirv::StructType::get(memberTypes, offsetInfo, memberDecorationsInfo);<br>
- // TODO(ravishankarm): Update StructType to have member name as attribute as<br>
+ // TODO: Update StructType to have member name as attribute as<br>
// well.<br>
return success();<br>
}<br>
@@ -1823,7 +1823,7 @@ spirv::LoopOp ControlFlowStructurizer::createLoopOp() {<br>
// merge block so that the newly created LoopOp will be inserted there.<br>
OpBuilder builder(&mergeBlock->front());<br>
<br>
- // TODO(antiagainst): handle loop control properly<br>
+ // TODO: handle loop control properly<br>
auto loopOp = builder.create<spirv::LoopOp>(location);<br>
loopOp.addEntryAndMergeBlock();<br>
<br>
@@ -1966,7 +1966,7 @@ LogicalResult ControlFlowStructurizer::structurizeImpl() {<br>
// selection/loop. If so, they will be recorded within blockMergeInfo.<br>
// We need to update the pointers there to the newly remapped ones so we can<br>
// continue structurizing them later.<br>
- // TODO(antiagainst): The asserts in the following assumes input SPIR-V blob<br>
+ // TODO: The asserts in the following assumes input SPIR-V blob<br>
// forms correctly nested selection/loop constructs. We should relax this<br>
// and support error cases better.<br>
auto it = blockMergeInfo.find(block);<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp b/mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp<br>
index f8641873fd95..8f6e02de27e7 100644<br>
--- a/mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp<br>
@@ -283,7 +283,7 @@ class Serializer {<br>
/// iterates the DenseElementsAttr to construct the constant array, and<br>
/// returns the result <id> associated with it. Returns 0 if failed. Note<br>
/// that the size of `index` must match the rank.<br>
- /// TODO(hanchung): Consider to enhance splat elements cases. For splat cases,<br>
+ /// TODO: Consider to enhance splat elements cases. For splat cases,<br>
/// we don't need to loop over all elements, especially when the splat value<br>
/// is zero. We can use OpConstantNull when the value is zero.<br>
uint32_t prepareDenseElementsConstant(Location loc, Type constType,<br>
@@ -511,7 +511,7 @@ LogicalResult Serializer::serialize() {<br>
if (failed(module.verify()))<br>
return failure();<br>
<br>
- // TODO(antiagainst): handle the other sections<br>
+ // TODO: handle the other sections<br>
processCapability();<br>
processExtension();<br>
processMemoryModel();<br>
@@ -773,7 +773,7 @@ LogicalResult Serializer::processFuncOp(spirv::FuncOp op) {<br>
operands.push_back(resTypeID);<br>
auto funcID = getOrCreateFunctionID(op.getName());<br>
operands.push_back(funcID);<br>
- // TODO : Support other function control options.<br>
+ // TODO: Support other function control options.<br>
operands.push_back(static_cast<uint32_t>(spirv::FunctionControl::None));<br>
operands.push_back(fnTypeID);<br>
encodeInstructionInto(functionHeader, spirv::Opcode::OpFunction, operands);<br>
@@ -1136,7 +1136,7 @@ Serializer::prepareBasicType(Location loc, Type type, uint32_t resultID,<br>
return success();<br>
}<br>
<br>
- // TODO(ravishankarm) : Handle other types.<br>
+ // TODO: Handle other types.<br>
return emitError(loc, "unhandled type in serialization: ") << type;<br>
}<br>
<br>
@@ -1229,7 +1229,7 @@ uint32_t Serializer::prepareArrayConstant(Location loc, Type constType,<br>
return resultID;<br>
}<br>
<br>
-// TODO(hanchung): Turn the below function into iterative function, instead of<br>
+// TODO: Turn the below function into iterative function, instead of<br>
// recursive function.<br>
uint32_t<br>
Serializer::prepareDenseElementsConstant(Location loc, Type constType,<br>
@@ -1572,7 +1572,7 @@ LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {<br>
auto emitSelectionMerge = [&]() {<br>
emitDebugLine(functionBody, loc);<br>
lastProcessedWasMergeInst = true;<br>
- // TODO(antiagainst): properly support selection control here<br>
+ // TODO: properly support selection control here<br>
encodeInstructionInto(<br>
functionBody, spirv::Opcode::OpSelectionMerge,<br>
{mergeID, static_cast<uint32_t>(spirv::SelectionControl::None)});<br>
@@ -1635,7 +1635,7 @@ LogicalResult Serializer::processLoopOp(spirv::LoopOp loopOp) {<br>
auto emitLoopMerge = [&]() {<br>
emitDebugLine(functionBody, loc);<br>
lastProcessedWasMergeInst = true;<br>
- // TODO(antiagainst): properly support loop control here<br>
+ // TODO: properly support loop control here<br>
encodeInstructionInto(<br>
functionBody, spirv::Opcode::OpLoopMerge,<br>
{mergeID, continueID, static_cast<uint32_t>(spirv::LoopControl::None)});<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp b/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp<br>
index 5bd425ae9107..be1d27141390 100644<br>
--- a/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp<br>
@@ -72,13 +72,13 @@ getInterfaceVariables(spirv::FuncOp funcOp,<br>
}<br>
llvm::SetVector<Operation *> interfaceVarSet;<br>
<br>
- // TODO(ravishankarm) : This should in reality traverse the entry function<br>
+ // TODO: This should in reality traverse the entry function<br>
// call graph and collect all the interfaces. For now, just traverse the<br>
// instructions in this function.<br>
funcOp.walk([&](spirv::AddressOfOp addressOfOp) {<br>
auto var =<br>
module.lookupSymbol<spirv::GlobalVariableOp>(addressOfOp.variable());<br>
- // TODO(antiagainst): Per SPIR-V spec: "Before version 1.4, the interface’s<br>
+ // TODO: Per SPIR-V spec: "Before version 1.4, the interface’s<br>
// storage classes are limited to the Input and Output storage classes.<br>
// Starting with version 1.4, the interface’s storage classes are all<br>
// storage classes used in declaring all global variables referenced by the<br>
@@ -158,7 +158,7 @@ LogicalResult ProcessInterfaceVarABI::matchAndRewrite(<br>
ConversionPatternRewriter &rewriter) const {<br>
if (!funcOp.getAttrOfType<spirv::EntryPointABIAttr>(<br>
spirv::getEntryPointABIAttrName())) {<br>
- // TODO(ravishankarm) : Non-entry point functions are not handled.<br>
+ // TODO: Non-entry point functions are not handled.<br>
return failure();<br>
}<br>
TypeConverter::SignatureConversion signatureConverter(<br>
@@ -169,7 +169,7 @@ LogicalResult ProcessInterfaceVarABI::matchAndRewrite(<br>
auto abiInfo = funcOp.getArgAttrOfType<spirv::InterfaceVarABIAttr>(<br>
argType.index(), attrName);<br>
if (!abiInfo) {<br>
- // TODO(ravishankarm) : For non-entry point functions, it should be legal<br>
+ // TODO: For non-entry point functions, it should be legal<br>
// to pass around scalar/vector values and return a scalar/vector. For now<br>
// non-entry point functions are not handled in this ABI lowering and will<br>
// produce an error.<br>
@@ -187,7 +187,7 @@ LogicalResult ProcessInterfaceVarABI::matchAndRewrite(<br>
rewriter.create<spirv::AddressOfOp>(funcOp.getLoc(), var);<br>
// Check if the arg is a scalar or vector type. In that case, the value<br>
// needs to be loaded into registers.<br>
- // TODO(ravishankarm) : This is loading value of the scalar into registers<br>
+ // TODO: This is loading value of the scalar into registers<br>
// at the start of the function. It is probably better to do the load just<br>
// before the use. There might be multiple loads and currently there is no<br>
// easy way to replace all uses with a sequence of operations.<br>
<br>
diff --git a/mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp b/mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp<br>
index 8adbc76a3a03..13e04f80c2b8 100644<br>
--- a/mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp<br>
+++ b/mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp<br>
@@ -163,7 +163,7 @@ void UpdateVCEPass::runOnOperation() {<br>
if (walkResult.wasInterrupted())<br>
return signalPassFailure();<br>
<br>
- // TODO(antiagainst): verify that the deduced version is consistent with<br>
+ // TODO: verify that the deduced version is consistent with<br>
// SPIR-V ops' maximal version requirements.<br>
<br>
auto triple = spirv::VerCapExtAttr::get(<br>
<br>
diff --git a/mlir/lib/Dialect/StandardOps/IR/Ops.cpp b/mlir/lib/Dialect/StandardOps/IR/Ops.cpp<br>
index b81f7f4c7387..f792e5d93e4e 100644<br>
--- a/mlir/lib/Dialect/StandardOps/IR/Ops.cpp<br>
+++ b/mlir/lib/Dialect/StandardOps/IR/Ops.cpp<br>
@@ -896,7 +896,7 @@ OpFoldResult CmpFOp::fold(ArrayRef<Attribute> operands) {<br>
auto lhs = operands.front().dyn_cast_or_null<FloatAttr>();<br>
auto rhs = operands.back().dyn_cast_or_null<FloatAttr>();<br>
<br>
- // TODO(gcmn) We could actually do some intelligent things if we know only one<br>
+ // TODO: We could actually do some intelligent things if we know only one<br>
// of the operands, but it's inf or nan.<br>
if (!lhs || !rhs)<br>
return {};<br>
<br>
diff --git a/mlir/lib/Dialect/Vector/VectorOps.cpp b/mlir/lib/Dialect/Vector/VectorOps.cpp<br>
index 184aed2ee1cd..f97906c2570d 100644<br>
--- a/mlir/lib/Dialect/Vector/VectorOps.cpp<br>
+++ b/mlir/lib/Dialect/Vector/VectorOps.cpp<br>
@@ -159,7 +159,7 @@ static ParseResult parseContractionOp(OpAsmParser &parser,<br>
Type resultType;<br>
auto loc = parser.getCurrentLocation();<br>
DictionaryAttr dictAttr;<br>
- // TODO(andydavis, ntv) Unify linalg op attribute parsing.<br>
+ // TODO: Unify linalg op attribute parsing.<br>
if (parser.parseAttribute(dictAttr, "_", result.attributes) ||<br>
parser.parseOperand(lhsInfo) || parser.parseComma() ||<br>
parser.parseOperand(rhsInfo) || parser.parseComma() ||<br>
@@ -192,7 +192,7 @@ static ParseResult parseContractionOp(OpAsmParser &parser,<br>
}<br>
<br>
static void print(OpAsmPrinter &p, ContractionOp op) {<br>
- // TODO(andydavis, ntv) Unify printing code with linalg ops.<br>
+ // TODO: Unify printing code with linalg ops.<br>
auto attrNames = op.getTraitAttrNames();<br>
llvm::StringSet<> traitAttrsSet;<br>
traitAttrsSet.insert(attrNames.begin(), attrNames.end());<br>
@@ -592,7 +592,7 @@ isValidExtractOrInsertSlicesType(Operation *op, VectorType vectorType,<br>
TupleType tupleType, ArrayRef<int64_t> sizes,<br>
ArrayRef<int64_t> strides) {<br>
// Check for non-unit strides.<br>
- // TODO(b/144845578) Support non-1 strides.<br>
+ // TODO: Support non-1 strides.<br>
if (llvm::any_of(strides, [](int64_t s) { return s != 1; }))<br>
return op->emitError("requires unit strides");<br>
// Check that 'vectorType' rank matches rank of tuple element vectors.<br>
@@ -864,7 +864,7 @@ void InsertStridedSliceOp::build(OpBuilder &builder, OperationState &result,<br>
result.addAttribute(getStridesAttrName(), stridesAttr);<br>
}<br>
<br>
-// TODO(ntv) Should be moved to Tablegen Confined attributes.<br>
+// TODO: Should be moved to Tablegen Confined attributes.<br>
template <typename OpType><br>
static LogicalResult isIntegerArrayAttrSmallerThanShape(OpType op,<br>
ArrayAttr arrayAttr,<br>
@@ -1331,7 +1331,7 @@ static LogicalResult verifyTransferOp(Operation *op, MemRefType memrefType,<br>
if (memrefVecEltRank > resultVecRank)<br>
return op->emitOpError(<br>
"requires memref vector element and vector result ranks to match.");<br>
- // TODO(b/146516564) Move this to isSuffix in Vector/Utils.h.<br>
+ // TODO: Move this to isSuffix in Vector/Utils.h.<br>
unsigned rankOffset = resultVecRank - memrefVecEltRank;<br>
auto memrefVecEltShape = memrefVectorElementType.getShape();<br>
auto resultVecShape = vectorType.getShape();<br>
<br>
diff --git a/mlir/lib/Dialect/Vector/VectorTransforms.cpp b/mlir/lib/Dialect/Vector/VectorTransforms.cpp<br>
index c7cf2937939c..19c5bdcf97f2 100644<br>
--- a/mlir/lib/Dialect/Vector/VectorTransforms.cpp<br>
+++ b/mlir/lib/Dialect/Vector/VectorTransforms.cpp<br>
@@ -101,7 +101,7 @@ static Type adjustType(VectorType tp, int64_t index) {<br>
}<br>
<br>
// Helper method to possibly drop a dimension in a load.<br>
-// TODO(ajcbik): use a reshaping vector load (and share lowering code)<br>
+// TODO<br>
static Value reshapeLoad(Location loc, Value val, VectorType type,<br>
int64_t index, int64_t pos,<br>
PatternRewriter &rewriter) {<br>
@@ -129,7 +129,7 @@ static Value reshapeLoad(Location loc, Value val, VectorType type,<br>
}<br>
<br>
// Helper method to possibly drop a dimension in a store.<br>
-// TODO(ajcbik): use a reshaping vector store (and share lowering code)<br>
+// TODO<br>
static Value reshapeStore(Location loc, Value val, Value result,<br>
VectorType type, int64_t index, int64_t pos,<br>
PatternRewriter &rewriter) {<br>
@@ -182,7 +182,7 @@ static void getMappedElements(const DenseMap<int64_t, int64_t> &indexMap,<br>
<br>
// Returns a tuple type with vector element types for each resulting slice<br>
// of 'vectorType' unrolled by 'sizes' and 'strides'.<br>
-// TODO(andydavis) Move this to a utility function and share it with<br>
+// TODO: Move this to a utility function and share it with<br>
// Extract/InsertSlicesOp verification.<br>
static TupleType generateExtractSlicesOpResultType(VectorType vectorType,<br>
ArrayRef<int64_t> sizes,<br>
@@ -276,7 +276,7 @@ static Value getOrCreateUnrolledVectorSlice(<br>
// Compute slice offsets.<br>
SmallVector<int64_t, 4> sliceOffsets(state.unrolledShape.size());<br>
getMappedElements(indexMap, offsets, sliceOffsets);<br>
- // TODO(b/144845578) Support non-1 strides.<br>
+ // TODO: Support non-1 strides.<br>
SmallVector<int64_t, 4> sliceStrides(state.unrolledShape.size(), 1);<br>
// Compute linear index of 'sliceOffsets' w.r.t 'state.basis'.<br>
int64_t sliceLinearIndex =<br>
@@ -347,7 +347,7 @@ struct VectorState {<br>
// insertslice<br>
// |<br>
<br>
-// TODO(andydavis) Add the following canonicalization/simplification patterns:<br>
+// TODO: Add the following canonicalization/simplification patterns:<br>
// *) Add pattern which matches InsertStridedSlice -> StridedSlice and forwards<br>
// InsertStridedSlice operand to StridedSlice.<br>
// *) Add pattern which matches SourceOp -> StridedSlice -> UserOp which checks<br>
@@ -357,7 +357,7 @@ struct VectorState {<br>
// operation, and leave the duplicate StridedSlice ops with no users<br>
// (removable with DCE).<br>
<br>
-// TODO(andydavis) Generalize this to support structured ops beyond<br>
+// TODO: Generalize this to support structured ops beyond<br>
// vector ContractionOp, and merge it with 'unrollSingleResultVectorOp'<br>
static Value unrollSingleResultStructuredOp(Operation *op,<br>
ArrayRef<int64_t> iterationBounds,<br>
@@ -473,7 +473,7 @@ static void getVectorContractionOpUnrollState(<br>
vectors.push_back({contractionOp.getRHSVectorMaskType(),<br>
vectors[1].indexMap, accOperandIndex + 2, false});<br>
}<br>
- // TODO(andydavis) Use linalg style 'args_in'/'args_out' to partition<br>
+ // TODO: Use linalg style 'args_in'/'args_out' to partition<br>
// 'vectors' instead of 'resultIndex'.<br>
resultIndex = accOperandIndex;<br>
}<br>
@@ -618,7 +618,7 @@ struct SplitTransferReadOp : public OpRewritePattern<vector::TransferReadOp> {<br>
<br>
LogicalResult matchAndRewrite(vector::TransferReadOp xferReadOp,<br>
PatternRewriter &rewriter) const override {<br>
- // TODO(andydavis, ntv) Support splitting TransferReadOp with non-identity<br>
+ // TODO: Support splitting TransferReadOp with non-identity<br>
// permutation maps. Repurpose code from MaterializeVectors transformation.<br>
if (!isIdentitySuffix(xferReadOp.permutation_map()))<br>
return failure();<br>
@@ -677,7 +677,7 @@ struct SplitTransferWriteOp : public OpRewritePattern<vector::TransferWriteOp> {<br>
<br>
LogicalResult matchAndRewrite(vector::TransferWriteOp xferWriteOp,<br>
PatternRewriter &rewriter) const override {<br>
- // TODO(andydavis, ntv) Support splitting TransferWriteOp with non-identity<br>
+ // TODO: Support splitting TransferWriteOp with non-identity<br>
// permutation maps. Repurpose code from MaterializeVectors transformation.<br>
if (!isIdentitySuffix(xferWriteOp.permutation_map()))<br>
return failure();<br>
@@ -1553,7 +1553,7 @@ namespace mlir {<br>
/// the vector.contract op is a row-major matrix multiply.<br>
LogicalResult<br>
ContractionOpToMatmulOpLowering::match(vector::ContractionOp op) const {<br>
- // TODO(ajcbik): implement masks<br>
+ // TODO: implement masks<br>
if (llvm::size(op.masks()) != 0)<br>
return failure();<br>
<br>
@@ -1619,7 +1619,7 @@ void ContractionOpToMatmulOpLowering::rewrite(vector::ContractionOp op,<br>
/// otherwise supports any layout permutation of the matrix-multiply.<br>
LogicalResult<br>
ContractionOpToOuterProductOpLowering ::match(vector::ContractionOp op) const {<br>
- // TODO(ajcbik): implement masks<br>
+ // TODO: implement masks<br>
if (llvm::size(op.masks()) != 0)<br>
return failure();<br>
<br>
@@ -1728,11 +1728,11 @@ void ContractionOpToOuterProductOpLowering::rewrite(<br>
///<br>
/// This only kicks in when VectorTransformsOptions is set to AXPY.<br>
//<br>
-// TODO (ajcbik): this is very similar, but not quite the same as<br>
-// the outerproduct lowering above; merge the two?<br>
+// TODO: this is very similar, but not quite the same as the outerproduct<br>
+// lowering above; merge the two?<br>
LogicalResult<br>
ContractionOpToAXPYLowering::match(vector::ContractionOp op) const {<br>
- // TODO(ajcbik): implement masks<br>
+ // TODO: implement masks<br>
if (llvm::size(op.masks()) != 0)<br>
return failure();<br>
<br>
@@ -1818,23 +1818,23 @@ void ContractionOpToAXPYLowering::rewrite(vector::ContractionOp op,<br>
/// This only kicks in when either VectorTransformsOptions is set<br>
/// to DOT or when other contraction patterns fail.<br>
//<br>
-// TODO(ajcbik): break down into transpose/reshape/cast ops<br>
+// TODO: break down into transpose/reshape/cast ops<br>
// when they become available to avoid code dup<br>
-// TODO(ajcbik): investigate lowering order impact on performance<br>
+// TODO: investigate lowering order impact on performance<br>
LogicalResult<br>
ContractionOpLowering::matchAndRewrite(vector::ContractionOp op,<br>
PatternRewriter &rewriter) const {<br>
<br>
- // TODO(ajcbik): implement masks.<br>
+ // TODO: implement masks.<br>
if (llvm::size(op.masks()) != 0)<br>
return failure();<br>
- // TODO(thomasraoux): support mixed mode contract lowering.<br>
+ // TODO: support mixed mode contract lowering.<br>
if (op.getLhsType().getElementType() !=<br>
getElementTypeOrSelf(op.getAccType()) ||<br>
op.getRhsType().getElementType() != getElementTypeOrSelf(op.getAccType()))<br>
return failure();<br>
<br>
- // TODO(ntv, ajcbik): implement benefits, cost models.<br>
+ // TODO: implement benefits, cost models.<br>
MLIRContext *ctx = op.getContext();<br>
ContractionOpToMatmulOpLowering pat1(vectorTransformsOptions, ctx);<br>
if (succeeded(pat1.match(op)))<br>
@@ -1895,7 +1895,7 @@ ContractionOpLowering::matchAndRewrite(vector::ContractionOp op,<br>
}<br>
<br>
// Lower one parallel dimension.<br>
-// TODO(ajcbik): consider reusing existing contract unrolling<br>
+// TODO: consider reusing existing contract unrolling<br>
Value ContractionOpLowering::lowerParallel(vector::ContractionOp op,<br>
int64_t lhsIndex, int64_t rhsIndex,<br>
PatternRewriter &rewriter) const {<br>
@@ -1998,8 +1998,8 @@ Value ContractionOpLowering::lowerReduction(vector::ContractionOp op,<br>
<br>
} // namespace mlir<br>
<br>
-// TODO(andydavis) Add pattern to rewrite ExtractSlices(ConstantMaskOp).<br>
-// TODO(andydavis) Add this as DRR pattern.<br>
+// TODO: Add pattern to rewrite ExtractSlices(ConstantMaskOp).<br>
+// TODO: Add this as DRR pattern.<br>
void mlir::vector::populateVectorToVectorTransformationPatterns(<br>
OwningRewritePatternList &patterns, MLIRContext *context) {<br>
// clang-format off<br>
<br>
diff --git a/mlir/lib/Dialect/Vector/VectorUtils.cpp b/mlir/lib/Dialect/Vector/VectorUtils.cpp<br>
index ccd243e8a7de..d5beaefc5eac 100644<br>
--- a/mlir/lib/Dialect/Vector/VectorUtils.cpp<br>
+++ b/mlir/lib/Dialect/Vector/VectorUtils.cpp<br>
@@ -208,7 +208,7 @@ static AffineMap makePermutationMap(<br>
<br>
/// Implementation detail that walks up the parents and records the ones with<br>
/// the specified type.<br>
-/// TODO(ntv): could also be implemented as a collect parents followed by a<br>
+/// TODO: could also be implemented as a collect parents followed by a<br>
/// filter and made available outside this file.<br>
template <typename T><br>
static SetVector<Operation *> getParentsOfType(Operation *op) {<br>
@@ -252,7 +252,7 @@ bool matcher::operatesOnSuperVectorsOf(Operation &op,<br>
// The ops that *may* lower a super-vector only do so if the super-vector to<br>
// sub-vector ratio exists. The ops that *must* lower a super-vector are<br>
// explicitly checked for this property.<br>
- /// TODO(ntv): there should be a single function for all ops to do this so we<br>
+ /// TODO: there should be a single function for all ops to do this so we<br>
/// do not have to special case. Maybe a trait, or just a method, unclear atm.<br>
bool mustDivide = false;<br>
(void)mustDivide;<br>
<br>
diff --git a/mlir/lib/ExecutionEngine/ExecutionEngine.cpp b/mlir/lib/ExecutionEngine/ExecutionEngine.cpp<br>
index c64c7d208dec..130ca3c02ad4 100644<br>
--- a/mlir/lib/ExecutionEngine/ExecutionEngine.cpp<br>
+++ b/mlir/lib/ExecutionEngine/ExecutionEngine.cpp<br>
@@ -234,7 +234,7 @@ Expected<std::unique_ptr<ExecutionEngine>> ExecutionEngine::create(<br>
<br>
// Clone module in a new LLVMContext since translateModuleToLLVMIR buries<br>
// ownership too deeply.<br>
- // TODO(zinenko): Reevaluate model of ownership of LLVMContext in LLVMDialect.<br>
+ // TODO: Reevaluate model of ownership of LLVMContext in LLVMDialect.<br>
std::unique_ptr<Module> deserModule =<br>
LLVM::cloneModuleIntoNewContext(ctx.get(), llvmModule.get());<br>
auto dataLayout = deserModule->getDataLayout();<br>
<br>
diff --git a/mlir/lib/IR/AffineExpr.cpp b/mlir/lib/IR/AffineExpr.cpp<br>
index 7d9145aaccce..e0c4b6b208f7 100644<br>
--- a/mlir/lib/IR/AffineExpr.cpp<br>
+++ b/mlir/lib/IR/AffineExpr.cpp<br>
@@ -703,7 +703,7 @@ void SimpleAffineExprFlattener::visitModExpr(AffineBinaryOpExpr expr) {<br>
auto rhsConst = operandExprStack.back()[getConstantIndex()];<br>
operandExprStack.pop_back();<br>
auto &lhs = operandExprStack.back();<br>
- // TODO(bondhugula): handle modulo by zero case when this issue is fixed<br>
+ // TODO: handle modulo by zero case when this issue is fixed<br>
// at the other places in the IR.<br>
assert(rhsConst > 0 && "RHS constant has to be positive");<br>
<br>
@@ -791,7 +791,7 @@ void SimpleAffineExprFlattener::visitDivExpr(AffineBinaryOpExpr expr,<br>
<br>
// This is a pure affine expr; the RHS is a positive constant.<br>
int64_t rhsConst = operandExprStack.back()[getConstantIndex()];<br>
- // TODO(bondhugula): handle division by zero at the same time the issue is<br>
+ // TODO: handle division by zero at the same time the issue is<br>
// fixed at other places.<br>
assert(rhsConst > 0 && "RHS constant has to be positive");<br>
operandExprStack.pop_back();<br>
@@ -870,7 +870,7 @@ int SimpleAffineExprFlattener::findLocalId(AffineExpr localExpr) {<br>
/// Simplify the affine expression by flattening it and reconstructing it.<br>
AffineExpr mlir::simplifyAffineExpr(AffineExpr expr, unsigned numDims,<br>
unsigned numSymbols) {<br>
- // TODO(bondhugula): only pure affine for now. The simplification here can<br>
+ // TODO: only pure affine for now. The simplification here can<br>
// be extended to semi-affine maps in the future.<br>
if (!expr.isPureAffine())<br>
return expr;<br>
<br>
diff --git a/mlir/lib/IR/AffineMap.cpp b/mlir/lib/IR/AffineMap.cpp<br>
index 07a01f0bf75f..050cb831f7a1 100644<br>
--- a/mlir/lib/IR/AffineMap.cpp<br>
+++ b/mlir/lib/IR/AffineMap.cpp<br>
@@ -444,7 +444,7 @@ bool MutableAffineMap::isMultipleOf(unsigned idx, int64_t factor) const {<br>
if (results[idx].isMultipleOf(factor))<br>
return true;<br>
<br>
- // TODO(bondhugula): use simplifyAffineExpr and FlatAffineConstraints to<br>
+ // TODO: use simplifyAffineExpr and FlatAffineConstraints to<br>
// complete this (for a more powerful analysis).<br>
return false;<br>
}<br>
@@ -453,7 +453,7 @@ bool MutableAffineMap::isMultipleOf(unsigned idx, int64_t factor) const {<br>
// be pure for the simplification implemented.<br>
void MutableAffineMap::simplify() {<br>
// Simplify each of the results if possible.<br>
- // TODO(ntv): functional-style map<br>
+ // TODO: functional-style map<br>
for (unsigned i = 0, e = getNumResults(); i < e; i++) {<br>
results[i] = simplifyAffineExpr(getResult(i), numDims, numSymbols);<br>
}<br>
<br>
diff --git a/mlir/lib/IR/AsmPrinter.cpp b/mlir/lib/IR/AsmPrinter.cpp<br>
index 0636ab59ea50..881f77f6004a 100644<br>
--- a/mlir/lib/IR/AsmPrinter.cpp<br>
+++ b/mlir/lib/IR/AsmPrinter.cpp<br>
@@ -284,7 +284,7 @@ class AliasState {<br>
// Utility to generate a function to register a symbol alias.<br>
static bool canRegisterAlias(StringRef name, llvm::StringSet<> &usedAliases) {<br>
assert(!name.empty() && "expected alias name to be non-empty");<br>
- // TODO(riverriddle) Assert that the provided alias name can be lexed as<br>
+ // TODO: Assert that the provided alias name can be lexed as<br>
// an identifier.<br>
<br>
// Check that the alias doesn't contain a '.' character and the name is not<br>
@@ -431,7 +431,7 @@ void AliasState::recordAttributeReference(Attribute attr) {<br>
/// Record a reference to the given type.<br>
void AliasState::recordTypeReference(Type ty) { usedTypes.insert(ty); }<br>
<br>
-// TODO Support visiting other types/operations when implemented.<br>
+// TODO: Support visiting other types/operations when implemented.<br>
void AliasState::visitType(Type type) {<br>
recordTypeReference(type);<br>
<br>
@@ -2442,7 +2442,7 @@ void Value::dump() {<br>
}<br>
<br>
void Value::printAsOperand(raw_ostream &os, AsmState &state) {<br>
- // TODO(riverriddle) This doesn't necessarily capture all potential cases.<br>
+ // TODO: This doesn't necessarily capture all potential cases.<br>
// Currently, region arguments can be shadowed when printing the main<br>
// operation. If the IR hasn't been printed, this will produce the old SSA<br>
// name and not the shadowed name.<br>
<br>
diff --git a/mlir/lib/IR/AttributeDetail.h b/mlir/lib/IR/AttributeDetail.h<br>
index e6c9ae5ed59c..ad0b302bc78d 100644<br>
--- a/mlir/lib/IR/AttributeDetail.h<br>
+++ b/mlir/lib/IR/AttributeDetail.h<br>
@@ -658,7 +658,7 @@ struct OpaqueElementsAttributeStorage : public AttributeStorage {<br>
/// Construct a new storage instance.<br>
static OpaqueElementsAttributeStorage *<br>
construct(AttributeStorageAllocator &allocator, KeyTy key) {<br>
- // TODO(b/131468830): Provide a way to avoid copying content of large opaque<br>
+ // TODO: Provide a way to avoid copying content of large opaque<br>
// tensors This will likely require a new reference attribute kind.<br>
return new (allocator.allocate<OpaqueElementsAttributeStorage>())<br>
OpaqueElementsAttributeStorage(std::get<0>(key), std::get<1>(key),<br>
<br>
diff --git a/mlir/lib/IR/Operation.cpp b/mlir/lib/IR/Operation.cpp<br>
index 23fb48b4993b..1e2a47639fdb 100644<br>
--- a/mlir/lib/IR/Operation.cpp<br>
+++ b/mlir/lib/IR/Operation.cpp<br>
@@ -280,7 +280,7 @@ InFlightDiagnostic Operation::emitError(const Twine &message) {<br>
if (getContext()->shouldPrintOpOnDiagnostic()) {<br>
// Print out the operation explicitly here so that we can print the generic<br>
// form.<br>
- // TODO(riverriddle) It would be nice if we could instead provide the<br>
+ // TODO: It would be nice if we could instead provide the<br>
// specific printing flags when adding the operation as an argument to the<br>
// diagnostic.<br>
std::string printedOp;<br>
<br>
diff --git a/mlir/lib/IR/StandardTypes.cpp b/mlir/lib/IR/StandardTypes.cpp<br>
index c76ff30d6c79..5a9d22148b76 100644<br>
--- a/mlir/lib/IR/StandardTypes.cpp<br>
+++ b/mlir/lib/IR/StandardTypes.cpp<br>
@@ -550,7 +550,7 @@ LogicalResult mlir::getStridesAndOffset(MemRefType t,<br>
// For now strides are only computed on a single affine map with a single<br>
// result (i.e. the closed subset of linearization maps that are compatible<br>
// with striding semantics).<br>
- // TODO(ntv): support more forms on a per-need basis.<br>
+ // TODO: support more forms on a per-need basis.<br>
if (affineMaps.size() > 1)<br>
return failure();<br>
if (affineMaps.size() == 1 && affineMaps[0].getNumResults() != 1)<br>
@@ -597,8 +597,8 @@ LogicalResult mlir::getStridesAndOffset(MemRefType t,<br>
<br>
/// In practice, a strided memref must be internally non-aliasing. Test<br>
/// against 0 as a proxy.<br>
- /// TODO(ntv) static cases can have more advanced checks.<br>
- /// TODO(ntv) dynamic cases would require a way to compare symbolic<br>
+ /// TODO: static cases can have more advanced checks.<br>
+ /// TODO: dynamic cases would require a way to compare symbolic<br>
/// expressions and would probably need an affine set context propagated<br>
/// everywhere.<br>
if (llvm::any_of(strides, [](AffineExpr e) {<br>
<br>
diff --git a/mlir/lib/IR/Visitors.cpp b/mlir/lib/IR/Visitors.cpp<br>
index 40ed0d934838..bbccdcbf7592 100644<br>
--- a/mlir/lib/IR/Visitors.cpp<br>
+++ b/mlir/lib/IR/Visitors.cpp<br>
@@ -14,7 +14,7 @@ using namespace mlir;<br>
/// Walk all of the operations nested under and including the given operations.<br>
void detail::walkOperations(Operation *op,<br>
function_ref<void(Operation *op)> callback) {<br>
- // TODO(b/140235992) This walk should be iterative over the operations.<br>
+ // TODO: This walk should be iterative over the operations.<br>
for (auto ®ion : op->getRegions())<br>
for (auto &block : region)<br>
// Early increment here in the case where the operation is erased.<br>
@@ -29,7 +29,7 @@ void detail::walkOperations(Operation *op,<br>
WalkResult<br>
detail::walkOperations(Operation *op,<br>
function_ref<WalkResult(Operation *op)> callback) {<br>
- // TODO(b/140235992) This walk should be iterative over the operations.<br>
+ // TODO: This walk should be iterative over the operations.<br>
for (auto ®ion : op->getRegions()) {<br>
for (auto &block : region) {<br>
// Early increment here in the case where the operation is erased.<br>
<br>
diff --git a/mlir/lib/Parser/AttributeParser.cpp b/mlir/lib/Parser/AttributeParser.cpp<br>
index 609d7ad3f8d2..65613a149ae9 100644<br>
--- a/mlir/lib/Parser/AttributeParser.cpp<br>
+++ b/mlir/lib/Parser/AttributeParser.cpp<br>
@@ -784,7 +784,7 @@ Attribute Parser::parseOpaqueElementsAttr(Type attrType) {<br>
<br>
auto name = getToken().getStringValue();<br>
auto *dialect = builder.getContext()->getRegisteredDialect(name);<br>
- // TODO(shpeisman): Allow for having an unknown dialect on an opaque<br>
+ // TODO: Allow for having an unknown dialect on an opaque<br>
// attribute. Otherwise, it can't be roundtripped without having the dialect<br>
// registered.<br>
if (!dialect)<br>
<br>
diff --git a/mlir/lib/Parser/DialectSymbolParser.cpp b/mlir/lib/Parser/DialectSymbolParser.cpp<br>
index 9d14d6f4fa4f..1a7e2c5448c1 100644<br>
--- a/mlir/lib/Parser/DialectSymbolParser.cpp<br>
+++ b/mlir/lib/Parser/DialectSymbolParser.cpp<br>
@@ -76,7 +76,7 @@ class CustomDialectAsmParser : public DialectAsmParser {<br>
return success();<br>
}<br>
<br>
- // TODO(riverriddle) support hex floating point values.<br>
+ // TODO: support hex floating point values.<br>
return emitError(getCurrentLocation(), "expected floating point literal");<br>
}<br>
<br>
<br>
diff --git a/mlir/lib/Parser/Parser.cpp b/mlir/lib/Parser/Parser.cpp<br>
index 465709d925e0..0e4589a20918 100644<br>
--- a/mlir/lib/Parser/Parser.cpp<br>
+++ b/mlir/lib/Parser/Parser.cpp<br>
@@ -1886,7 +1886,7 @@ OwningModuleRef mlir::parseSourceFile(StringRef filename,<br>
llvm::SourceMgr &sourceMgr,<br>
MLIRContext *context) {<br>
if (sourceMgr.getNumBuffers() != 0) {<br>
- // TODO(b/136086478): Extend to support multiple buffers.<br>
+ // TODO: Extend to support multiple buffers.<br>
emitError(mlir::UnknownLoc::get(context),<br>
"only main buffer parsed at the moment");<br>
return nullptr;<br>
<br>
diff --git a/mlir/lib/Pass/PassRegistry.cpp b/mlir/lib/Pass/PassRegistry.cpp<br>
index fc1beae3a2d8..442233024bbe 100644<br>
--- a/mlir/lib/Pass/PassRegistry.cpp<br>
+++ b/mlir/lib/Pass/PassRegistry.cpp<br>
@@ -128,7 +128,7 @@ void detail::PassOptions::copyOptionValuesFrom(const PassOptions &other) {<br>
}<br>
<br>
LogicalResult detail::PassOptions::parseFromString(StringRef options) {<br>
- // TODO(parkers): Handle escaping strings.<br>
+ // TODO: Handle escaping strings.<br>
// NOTE: `options` is modified in place to always refer to the unprocessed<br>
// part of the string.<br>
while (!options.empty()) {<br>
@@ -199,7 +199,7 @@ void detail::PassOptions::printHelp(size_t indent, size_t descIndent) const {<br>
};<br>
llvm::array_pod_sort(orderedOps.begin(), orderedOps.end(), compareOptionArgs);<br>
for (OptionBase *option : orderedOps) {<br>
- // TODO(riverriddle) printOptionInfo assumes a specific indent and will<br>
+ // TODO: printOptionInfo assumes a specific indent and will<br>
// print options with values with incorrect indentation. We should add<br>
// support to llvm::cl::Option for passing in a base indent to use when<br>
// printing.<br>
@@ -328,7 +328,7 @@ LogicalResult TextualPipeline::parsePipelineText(StringRef text,<br>
// Skip over everything until the closing '}' and store as options.<br>
size_t close = text.find('}');<br>
<br>
- // TODO(parkers): Handle skipping over quoted sub-strings.<br>
+ // TODO: Handle skipping over quoted sub-strings.<br>
if (close == StringRef::npos) {<br>
return errorHandler(<br>
/*rawLoc=*/text.data() - 1,<br>
<br>
diff --git a/mlir/lib/TableGen/OpClass.cpp b/mlir/lib/TableGen/OpClass.cpp<br>
index 2b9da7355929..09cb6cb9e007 100644<br>
--- a/mlir/lib/TableGen/OpClass.cpp<br>
+++ b/mlir/lib/TableGen/OpClass.cpp<br>
@@ -30,7 +30,7 @@ void tblgen::OpMethodSignature::writeDeclTo(raw_ostream &os) const {<br>
void tblgen::OpMethodSignature::writeDefTo(raw_ostream &os,<br>
StringRef namePrefix) const {<br>
// We need to remove the default values for parameters in method definition.<br>
- // TODO(antiagainst): We are using '=' and ',' as delimiters for parameter<br>
+ // TODO: We are using '=' and ',' as delimiters for parameter<br>
// initializers. This is incorrect for initializer list with more than one<br>
// element. Change to a more robust approach.<br>
auto removeParamDefaultValue = [](StringRef params) {<br>
<br>
diff --git a/mlir/lib/TableGen/Predicate.cpp b/mlir/lib/TableGen/Predicate.cpp<br>
index 2ebec1b3b6ee..bf617318e694 100644<br>
--- a/mlir/lib/TableGen/Predicate.cpp<br>
+++ b/mlir/lib/TableGen/Predicate.cpp<br>
@@ -213,7 +213,7 @@ static PredNode *propagateGroundTruth(<br>
// still point to the original predicate records. While the original<br>
// predicate may be known to be true or false, it is not necessarily the case<br>
// after rewriting.<br>
- // TODO(zinenko,jpienaar): we can support ground truth for rewritten<br>
+ // TODO: we can support ground truth for rewritten<br>
// predicates by either (a) having our own unique'ing of the predicates<br>
// instead of relying on TableGen record pointers or (b) taking ground truth<br>
// values optionally prefixed with a list of substitutions to apply, e.g.<br>
<br>
diff --git a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp<br>
index 74dd0d15f441..f40f44f2fbc6 100644<br>
--- a/mlir/lib/Target/LLVMIR/DebugTranslation.cpp<br>
+++ b/mlir/lib/Target/LLVMIR/DebugTranslation.cpp<br>
@@ -32,7 +32,7 @@ DebugTranslation::DebugTranslation(Operation *module, llvm::Module &llvmModule)<br>
if (!module->walk(interruptIfValidLocation).wasInterrupted())<br>
return;<br>
<br>
- // TODO(riverriddle) Several parts of this are incorrect. Different source<br>
+ // TODO: Several parts of this are incorrect. Different source<br>
// languages may interpret <br>
diff erent parts of the debug information<br>
// <br>
diff erently. Frontends will also want to pipe in various information, like<br>
// flags. This is fine for now as we only emit line-table information and not<br>
@@ -75,7 +75,7 @@ void DebugTranslation::translate(LLVMFuncOp func, llvm::Function &llvmFunc) {<br>
auto *file = translateFile(fileLoc ? fileLoc.getFilename() : "<unknown>");<br>
unsigned line = fileLoc ? fileLoc.getLine() : 0;<br>
<br>
- // TODO(riverriddle) This is the bare essentials for now. We will likely end<br>
+ // TODO: This is the bare essentials for now. We will likely end<br>
// up with wrapper metadata around LLVMs metadata in the future, so this<br>
// doesn't need to be smart until then.<br>
llvm::DISubroutineType *type =<br>
<br>
diff --git a/mlir/lib/Target/LLVMIR/DebugTranslation.h b/mlir/lib/Target/LLVMIR/DebugTranslation.h<br>
index ae04f2b1d488..062b8820c5a8 100644<br>
--- a/mlir/lib/Target/LLVMIR/DebugTranslation.h<br>
+++ b/mlir/lib/Target/LLVMIR/DebugTranslation.h<br>
@@ -54,7 +54,7 @@ class DebugTranslation {<br>
locationToLoc;<br>
<br>
/// A mapping between filename and llvm debug file.<br>
- /// TODO(riverriddle) Change this to DenseMap<Identifier, ...> when we can<br>
+ /// TODO: Change this to DenseMap<Identifier, ...> when we can<br>
/// access the Identifier filename in FileLineColLoc.<br>
llvm::StringMap<llvm::DIFile *> fileMap;<br>
<br>
<br>
diff --git a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp<br>
index 075ce9f6089f..08150745e80b 100644<br>
--- a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp<br>
+++ b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp<br>
@@ -601,7 +601,7 @@ void ModuleTranslation::connectPHINodes(LLVMFuncOp func) {<br>
}<br>
}<br>
<br>
-// TODO(mlir-team): implement an iterative version<br>
+// TODO: implement an iterative version<br>
static void topologicalSortImpl(llvm::SetVector<Block *> &blocks, Block *b) {<br>
blocks.insert(b);<br>
for (Block *bb : b->getSuccessors()) {<br>
<br>
diff --git a/mlir/lib/Transforms/CSE.cpp b/mlir/lib/Transforms/CSE.cpp<br>
index f7cf7f1c8e95..eb31fd207d79 100644<br>
--- a/mlir/lib/Transforms/CSE.cpp<br>
+++ b/mlir/lib/Transforms/CSE.cpp<br>
@@ -106,7 +106,7 @@ LogicalResult CSE::simplifyOperation(ScopedMapTy &knownValues, Operation *op) {<br>
if (op->getNumRegions() != 0)<br>
return failure();<br>
<br>
- // TODO(riverriddle) We currently only eliminate non side-effecting<br>
+ // TODO: We currently only eliminate non side-effecting<br>
// operations.<br>
if (!MemoryEffectOpInterface::hasNoEffect(op))<br>
return failure();<br>
<br>
diff --git a/mlir/lib/Transforms/DialectConversion.cpp b/mlir/lib/Transforms/DialectConversion.cpp<br>
index 60c9e78b7a69..9401121eed96 100644<br>
--- a/mlir/lib/Transforms/DialectConversion.cpp<br>
+++ b/mlir/lib/Transforms/DialectConversion.cpp<br>
@@ -1104,7 +1104,7 @@ Block *ConversionPatternRewriter::splitBlock(Block *block,<br>
/// PatternRewriter hook for merging a block into another.<br>
void ConversionPatternRewriter::mergeBlocks(Block *source, Block *dest,<br>
ValueRange argValues) {<br>
- // TODO(riverriddle) This requires fixing the implementation of<br>
+ // TODO: This requires fixing the implementation of<br>
// 'replaceUsesOfBlockArgument', which currently isn't undoable.<br>
llvm_unreachable("block merging updates are currently not supported");<br>
}<br>
@@ -1381,7 +1381,7 @@ OperationLegalizer::legalize(Operation *op,<br>
}<br>
<br>
// If the operation isn't legal, try to fold it in-place.<br>
- // TODO(riverriddle) Should we always try to do this, even if the op is<br>
+ // TODO: Should we always try to do this, even if the op is<br>
// already legal?<br>
if (succeeded(legalizeWithFold(op, rewriter))) {<br>
LLVM_DEBUG({<br>
<br>
diff --git a/mlir/lib/Transforms/Inliner.cpp b/mlir/lib/Transforms/Inliner.cpp<br>
index e17a379d54b8..2ddb10a3a088 100644<br>
--- a/mlir/lib/Transforms/Inliner.cpp<br>
+++ b/mlir/lib/Transforms/Inliner.cpp<br>
@@ -321,7 +321,7 @@ static void collectCallOps(iterator_range<Region::iterator> blocks,<br>
<br>
for (Operation &op : *block) {<br>
if (auto call = dyn_cast<CallOpInterface>(op)) {<br>
- // TODO(riverriddle) Support inlining nested call references.<br>
+ // TODO: Support inlining nested call references.<br>
CallInterfaceCallable callable = call.getCallableForCallee();<br>
if (SymbolRefAttr symRef = callable.dyn_cast<SymbolRefAttr>()) {<br>
if (!symRef.isa<FlatSymbolRefAttr>())<br>
<br>
diff --git a/mlir/lib/Transforms/LoopFusion.cpp b/mlir/lib/Transforms/LoopFusion.cpp<br>
index f71ff2aba9e9..c2f30fa3d189 100644<br>
--- a/mlir/lib/Transforms/LoopFusion.cpp<br>
+++ b/mlir/lib/Transforms/LoopFusion.cpp<br>
@@ -42,9 +42,9 @@ namespace {<br>
/// which fuses loop nests with single-writer/single-reader memref dependences<br>
/// with the goal of improving locality.<br>
<br>
-// TODO(andydavis) Support fusion of source loop nests which write to multiple<br>
+// TODO: Support fusion of source loop nests which write to multiple<br>
// memrefs, where each memref can have multiple users (if profitable).<br>
-// TODO(andydavis) Extend this pass to check for fusion preventing dependences,<br>
+// TODO: Extend this pass to check for fusion preventing dependences,<br>
// and add support for more general loop fusion algorithms.<br>
<br>
struct LoopFusion : public AffineLoopFusionBase<LoopFusion> {<br>
@@ -68,7 +68,7 @@ mlir::createLoopFusionPass(unsigned fastMemorySpace,<br>
maximalFusion);<br>
}<br>
<br>
-// TODO(b/117228571) Replace when this is modeled through side-effects/op traits<br>
+// TODO: Replace when this is modeled through side-effects/op traits<br>
static bool isMemRefDereferencingOp(Operation &op) {<br>
return isa<AffineReadOpInterface, AffineWriteOpInterface, AffineDmaStartOp,<br>
AffineDmaWaitOp>(op);<br>
@@ -101,8 +101,8 @@ struct LoopNestStateCollector {<br>
// MemRefDependenceGraph is a graph data structure where graph nodes are<br>
// top-level operations in a FuncOp which contain load/store ops, and edges<br>
// are memref dependences between the nodes.<br>
-// TODO(andydavis) Add a more flexible dependence graph representation.<br>
-// TODO(andydavis) Add a depth parameter to dependence graph construction.<br>
+// TODO: Add a more flexible dependence graph representation.<br>
+// TODO: Add a depth parameter to dependence graph construction.<br>
struct MemRefDependenceGraph {<br>
public:<br>
// Node represents a node in the graph. A Node is either an entire loop nest<br>
@@ -628,7 +628,7 @@ struct MemRefDependenceGraph {<br>
<br>
// Initializes the data dependence graph by walking operations in 'f'.<br>
// Assigns each node in the graph a node id based on program order in 'f'.<br>
-// TODO(andydavis) Add support for taking a Block arg to construct the<br>
+// TODO: Add support for taking a Block arg to construct the<br>
// dependence graph at a <br>
diff erent depth.<br>
bool MemRefDependenceGraph::init(FuncOp f) {<br>
DenseMap<Value, SetVector<unsigned>> memrefAccesses;<br>
@@ -796,7 +796,7 @@ static unsigned getMaxLoopDepth(ArrayRef<Operation *> loadOpInsts,<br>
getNumCommonSurroundingLoops(*srcOpInst, *dstOpInst);<br>
for (unsigned d = 1; d <= numCommonLoops + 1; ++d) {<br>
FlatAffineConstraints dependenceConstraints;<br>
- // TODO(andydavis) Cache dependence analysis results, check cache here.<br>
+ // TODO: Cache dependence analysis results, check cache here.<br>
DependenceResult result = checkMemrefAccessDependence(<br>
srcAccess, dstAccess, d, &dependenceConstraints,<br>
/*dependenceComponents=*/nullptr);<br>
@@ -823,7 +823,7 @@ static void sinkSequentialLoops(MemRefDependenceGraph::Node *node) {<br>
node->op = newRootForOp.getOperation();<br>
}<br>
<br>
-// TODO(mlir-team): improve/complete this when we have target data.<br>
+// TODO: improve/complete this when we have target data.<br>
static unsigned getMemRefEltSizeInBytes(MemRefType memRefType) {<br>
auto elementType = memRefType.getElementType();<br>
<br>
@@ -841,7 +841,7 @@ static unsigned getMemRefEltSizeInBytes(MemRefType memRefType) {<br>
// Creates and returns a private (single-user) memref for fused loop rooted<br>
// at 'forOp', with (potentially reduced) memref size based on the<br>
// MemRefRegion written to by 'srcStoreOpInst' at depth 'dstLoopDepth'.<br>
-// TODO(bondhugula): consider refactoring the common code from generateDma and<br>
+// TODO: consider refactoring the common code from generateDma and<br>
// this one.<br>
static Value createPrivateMemRef(AffineForOp forOp, Operation *srcStoreOpInst,<br>
unsigned dstLoopDepth,<br>
@@ -912,7 +912,7 @@ static Value createPrivateMemRef(AffineForOp forOp, Operation *srcStoreOpInst,<br>
<br>
// Create new private memref for fused loop 'forOp'. 'newShape' is always<br>
// a constant shape.<br>
- // TODO(andydavis) Create/move alloc ops for private memrefs closer to their<br>
+ // TODO: Create/move alloc ops for private memrefs closer to their<br>
// consumer loop nests to reduce their live range. Currently they are added<br>
// at the beginning of the function, because loop nests can be reordered<br>
// during the fusion pass.<br>
@@ -1012,7 +1012,7 @@ static bool hasNonAffineUsersOnThePath(unsigned srcId, unsigned dstId,<br>
// 'srcLiveOutStoreOp', has output edges.<br>
// Returns true if 'dstNode's read/write region to 'memref' is a super set of<br>
// 'srcNode's write region to 'memref' and 'srcId' has only one output edge.<br>
-// TODO(andydavis) Generalize this to handle more live in/out cases.<br>
+// TODO: Generalize this to handle more live in/out cases.<br>
static bool<br>
canFuseSrcWhichWritesToLiveOut(unsigned srcId, unsigned dstId,<br>
AffineWriteOpInterface srcLiveOutStoreOp,<br>
@@ -1040,7 +1040,7 @@ canFuseSrcWhichWritesToLiveOut(unsigned srcId, unsigned dstId,<br>
return false;<br>
<br>
// Compute MemRefRegion 'dstRegion' for 'dstStore/LoadOpInst' on 'memref'.<br>
- // TODO(andydavis) Compute 'unionboundingbox' of all write regions (one for<br>
+ // TODO: Compute 'unionboundingbox' of all write regions (one for<br>
// each store op in 'dstStoreOps').<br>
SmallVector<Operation *, 2> dstStoreOps;<br>
dstNode->getStoreOpsForMemref(memref, &dstStoreOps);<br>
@@ -1064,7 +1064,7 @@ canFuseSrcWhichWritesToLiveOut(unsigned srcId, unsigned dstId,<br>
<br>
// Return false if write region is not a superset of 'srcNodes' write<br>
// region to 'memref'.<br>
- // TODO(andydavis) Check the shape and lower bounds here too.<br>
+ // TODO: Check the shape and lower bounds here too.<br>
if (srcNumElements != dstNumElements)<br>
return false;<br>
<br>
@@ -1244,7 +1244,7 @@ static bool isFusionProfitable(Operation *srcOpInst, Operation *srcStoreOpInst,<br>
maybeSliceWriteRegionSizeBytes.getValue();<br>
<br>
// If we are fusing for reuse, check that write regions remain the same.<br>
- // TODO(andydavis) Write region check should check sizes and offsets in<br>
+ // TODO: Write region check should check sizes and offsets in<br>
// each dimension, so that we are sure they are covering the same memref<br>
// region. Also, move this out to a isMemRefRegionSuperSet helper function.<br>
if (srcOpInst != srcStoreOpInst &&<br>
@@ -1268,7 +1268,7 @@ static bool isFusionProfitable(Operation *srcOpInst, Operation *srcStoreOpInst,<br>
llvm::dbgs() << msg.str();<br>
});<br>
<br>
- // TODO(b/123247369): This is a placeholder cost model.<br>
+ // TODO: This is a placeholder cost model.<br>
// Among all choices that add an acceptable amount of redundant computation<br>
// (as per computeToleranceThreshold), we will simply pick the one that<br>
// reduces the intermediary size the most.<br>
@@ -1424,9 +1424,10 @@ namespace {<br>
// takes O(V) time for initialization, and has runtime O(V + E).<br>
//<br>
// This greedy algorithm is not 'maximal' due to the current restriction of<br>
-// fusing along single producer consumer edges, but there is a TODO to fix this.<br>
+// fusing along single producer consumer edges, but there is a TODO: to fix<br>
+// this.<br>
//<br>
-// TODO(andydavis) Experiment with other fusion policies.<br>
+// TODO: Experiment with other fusion policies.<br>
struct GreedyFusion {<br>
public:<br>
// The data dependence graph to traverse during fusion.<br>
@@ -1457,7 +1458,7 @@ struct GreedyFusion {<br>
<br>
// Initializes 'worklist' with nodes from 'mdg'<br>
void init() {<br>
- // TODO(andydavis) Add a priority queue for prioritizing nodes by <br>
diff erent<br>
+ // TODO: Add a priority queue for prioritizing nodes by <br>
diff erent<br>
// metrics (e.g. arithmetic intensity/flops-to-bytes ratio).<br>
worklist.clear();<br>
worklistSet.clear();<br>
@@ -1474,7 +1475,7 @@ struct GreedyFusion {<br>
// *) Second pass fuses sibling nodes which share no dependence edges.<br>
// *) Third pass fuses any remaining producer nodes into their users.<br>
void run() {<br>
- // TODO(andydavis) Run this repeatedly until a fixed-point is reached.<br>
+ // TODO: Run this repeatedly until a fixed-point is reached.<br>
fuseProducerConsumerNodes(/*maxSrcUserCount=*/1);<br>
fuseSiblingNodes();<br>
fuseProducerConsumerNodes(<br>
@@ -1537,7 +1538,7 @@ struct GreedyFusion {<br>
continue;<br>
// Skip if 'srcNode' has more than one live-out store to a<br>
// function-local memref.<br>
- // TODO(andydavis) Support more generic multi-output src loop nests<br>
+ // TODO: Support more generic multi-output src loop nests<br>
// fusion.<br>
auto srcStoreOp = mdg->getUniqueOutgoingStore(srcNode);<br>
if (!srcStoreOp) {<br>
@@ -1602,7 +1603,7 @@ struct GreedyFusion {<br>
unsigned dstLoopDepthTest = getInnermostCommonLoopDepth(dstOps);<br>
// Check the feasibility of fusing src loop nest into dst loop nest<br>
// at loop depths in range [1, dstLoopDepthTest].<br>
- // TODO(andydavis) Use slice union computation and union of memref<br>
+ // TODO: Use slice union computation and union of memref<br>
// read/write regions to cost model and fusion.<br>
bool canFuse = false;<br>
for (unsigned i = 1; i <= dstLoopDepthTest; ++i) {<br>
@@ -1663,7 +1664,7 @@ struct GreedyFusion {<br>
memref)<br>
storesForMemref.push_back(storeOpInst);<br>
}<br>
- // TODO(andydavis) Use union of memref write regions to compute<br>
+ // TODO: Use union of memref write regions to compute<br>
// private memref footprint.<br>
auto newMemRef = createPrivateMemRef(<br>
dstAffineForOp, storesForMemref[0], bestDstLoopDepth,<br>
@@ -1765,7 +1766,7 @@ struct GreedyFusion {<br>
while (findSiblingNodeToFuse(dstNode, &visitedSibNodeIds, &idAndMemref)) {<br>
unsigned sibId = idAndMemref.first;<br>
Value memref = idAndMemref.second;<br>
- // TODO(andydavis) Check that 'sibStoreOpInst' post-dominates all other<br>
+ // TODO: Check that 'sibStoreOpInst' post-dominates all other<br>
// stores to the same memref in 'sibNode' loop nest.<br>
auto *sibNode = mdg->getNode(sibId);<br>
// Compute an operation list insertion point for the fused loop<br>
@@ -1787,7 +1788,7 @@ struct GreedyFusion {<br>
assert(sibLoadOpInsts.size() == 1);<br>
Operation *sibLoadOpInst = sibLoadOpInsts[0];<br>
assert(!sibNode->stores.empty());<br>
- // TODO(andydavis) Choose the store which postdominates all other stores.<br>
+ // TODO: Choose the store which postdominates all other stores.<br>
auto *sibStoreOpInst = sibNode->stores.back();<br>
<br>
// Gather 'dstNode' load ops to 'memref'.<br>
@@ -1833,7 +1834,7 @@ struct GreedyFusion {<br>
// on 'memref'.<br>
auto canFuseWithSibNode = [&](Node *sibNode, Value memref) {<br>
// Skip if 'outEdge' is not a read-after-write dependence.<br>
- // TODO(andydavis) Remove restrict to single load op restriction.<br>
+ // TODO: Remove restrict to single load op restriction.<br>
if (sibNode->getLoadOpCount(memref) != 1)<br>
return false;<br>
// Skip if there exists a path of dependent edges between<br>
<br>
diff --git a/mlir/lib/Transforms/MemRefDataFlowOpt.cpp b/mlir/lib/Transforms/MemRefDataFlowOpt.cpp<br>
index 75ac0a5197f3..7220fd1f3dc6 100644<br>
--- a/mlir/lib/Transforms/MemRefDataFlowOpt.cpp<br>
+++ b/mlir/lib/Transforms/MemRefDataFlowOpt.cpp<br>
@@ -8,7 +8,7 @@<br>
//<br>
// This file implements a pass to forward memref stores to loads, thereby<br>
// potentially getting rid of intermediate memref's entirely.<br>
-// TODO(mlir-team): In the future, similar techniques could be used to eliminate<br>
+// TODO: In the future, similar techniques could be used to eliminate<br>
// dead memref store's and perform more complex forwarding when support for<br>
// SSA scalars live out of 'affine.for'/'affine.if' statements is available.<br>
//===----------------------------------------------------------------------===//<br>
@@ -54,9 +54,9 @@ namespace {<br>
// don't reason about loops that are guaranteed to execute at least once or<br>
// multiple sources to forward from.<br>
//<br>
-// TODO(mlir-team): more forwarding can be done when support for<br>
+// TODO: more forwarding can be done when support for<br>
// loop/conditional live-out SSA values is available.<br>
-// TODO(mlir-team): do general dead store elimination for memref's. This pass<br>
+// TODO: do general dead store elimination for memref's. This pass<br>
// currently only eliminates the stores only if no other loads/uses (other<br>
// than dealloc) remain.<br>
//<br>
@@ -203,7 +203,7 @@ void MemRefDataFlowOpt::runOnFunction() {<br>
// If the memref hasn't been alloc'ed in this function, skip.<br>
Operation *defOp = memref.getDefiningOp();<br>
if (!defOp || !isa<AllocOp>(defOp))<br>
- // TODO(mlir-team): if the memref was returned by a 'call' operation, we<br>
+ // TODO: if the memref was returned by a 'call' operation, we<br>
// could still erase it if the call had no side-effects.<br>
continue;<br>
if (llvm::any_of(memref.getUsers(), [&](Operation *ownerOp) {<br>
<br>
diff --git a/mlir/lib/Transforms/PipelineDataTransfer.cpp b/mlir/lib/Transforms/PipelineDataTransfer.cpp<br>
index cb2703643d8d..564193e22690 100644<br>
--- a/mlir/lib/Transforms/PipelineDataTransfer.cpp<br>
+++ b/mlir/lib/Transforms/PipelineDataTransfer.cpp<br>
@@ -46,7 +46,7 @@ std::unique_ptr<OperationPass<FuncOp>> mlir::createPipelineDataTransferPass() {<br>
<br>
// Returns the position of the tag memref operand given a DMA operation.<br>
// Temporary utility: will be replaced when DmaStart/DmaFinish abstract op's are<br>
-// added. TODO(b/117228571)<br>
+// added. TODO<br>
static unsigned getTagMemRefPos(Operation &dmaOp) {<br>
assert((isa<AffineDmaStartOp, AffineDmaWaitOp>(dmaOp)));<br>
if (auto dmaStartOp = dyn_cast<AffineDmaStartOp>(dmaOp)) {<br>
@@ -149,7 +149,7 @@ static bool checkTagMatch(AffineDmaStartOp startOp, AffineDmaWaitOp waitOp) {<br>
e = startIndices.end();<br>
it != e; ++it, ++wIt) {<br>
// Keep it simple for now, just checking if indices match.<br>
- // TODO(mlir-team): this would in general need to check if there is no<br>
+ // TODO: this would in general need to check if there is no<br>
// intervening write writing to the same tag location, i.e., memory last<br>
// write/data flow analysis. This is however sufficient/powerful enough for<br>
// now since the DMA generation pass or the input for it will always have<br>
@@ -185,12 +185,12 @@ static void findMatchingStartFinishInsts(<br>
continue;<br>
<br>
// Only DMAs incoming into higher memory spaces are pipelined for now.<br>
- // TODO(bondhugula): handle outgoing DMA pipelining.<br>
+ // TODO: handle outgoing DMA pipelining.<br>
if (!dmaStartOp.isDestMemorySpaceFaster())<br>
continue;<br>
<br>
// Check for dependence with outgoing DMAs. Doing this conservatively.<br>
- // TODO(andydavis,bondhugula): use the dependence analysis to check for<br>
+ // TODO: use the dependence analysis to check for<br>
// dependences between an incoming and outgoing DMA in the same iteration.<br>
auto it = outgoingDmaOps.begin();<br>
for (; it != outgoingDmaOps.end(); ++it) {<br>
@@ -252,8 +252,8 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) {<br>
// Identify memref's to replace by scanning through all DMA start<br>
// operations. A DMA start operation has two memref's - the one from the<br>
// higher level of memory hierarchy is the one to double buffer.<br>
- // TODO(bondhugula): check whether double-buffering is even necessary.<br>
- // TODO(bondhugula): make this work with <br>
diff erent layouts: assuming here that<br>
+ // TODO: check whether double-buffering is even necessary.<br>
+ // TODO: make this work with <br>
diff erent layouts: assuming here that<br>
// the dimension we are adding here for the double buffering is the outermost<br>
// dimension.<br>
for (auto &pair : startWaitPairs) {<br>
<br>
diff --git a/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp b/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp<br>
index ea420733e5ff..14a4c7417249 100644<br>
--- a/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp<br>
+++ b/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp<br>
@@ -110,7 +110,7 @@ class GreedyPatternRewriteDriver : public PatternRewriter {<br>
for (Value operand : operands) {<br>
// If the use count of this operand is now < 2, we re-add the defining<br>
// operation to the worklist.<br>
- // TODO(riverriddle) This is based on the fact that zero use operations<br>
+ // TODO: This is based on the fact that zero use operations<br>
// may be deleted, and that single use values often have more<br>
// canonicalization opportunities.<br>
if (!operand.use_empty() && !operand.hasOneUse())<br>
<br>
diff --git a/mlir/lib/Transforms/Utils/LoopFusionUtils.cpp b/mlir/lib/Transforms/Utils/LoopFusionUtils.cpp<br>
index 18fc872cdf7f..17dbf8eb166d 100644<br>
--- a/mlir/lib/Transforms/Utils/LoopFusionUtils.cpp<br>
+++ b/mlir/lib/Transforms/Utils/LoopFusionUtils.cpp<br>
@@ -164,7 +164,7 @@ static Operation *getFusedLoopNestInsertionPoint(AffineForOp srcForOp,<br>
return nullptr;<br>
}<br>
// Return insertion point in valid range closest to 'opB'.<br>
- // TODO(andydavis) Consider other insertion points in valid range.<br>
+ // TODO: Consider other insertion points in valid range.<br>
return firstDepOpA;<br>
}<br>
// No dependences from 'opA' to operation in range ('opA', 'opB'), return<br>
@@ -187,7 +187,7 @@ gatherLoadsAndStores(AffineForOp forOp,<br>
return !hasIfOp;<br>
}<br>
<br>
-// TODO(andydavis) Prevent fusion of loop nests with side-effecting operations.<br>
+// TODO: Prevent fusion of loop nests with side-effecting operations.<br>
FusionResult mlir::canFuseLoops(AffineForOp srcForOp, AffineForOp dstForOp,<br>
unsigned dstLoopDepth,<br>
ComputationSliceState *srcSlice) {<br>
@@ -361,7 +361,7 @@ static int64_t getComputeCostHelper(<br>
return tripCount * opCount;<br>
}<br>
<br>
-// TODO(andydavis,b/126426796): extend this to handle multiple result maps.<br>
+// TODO: extend this to handle multiple result maps.<br>
static Optional<uint64_t> getConstDifference(AffineMap lbMap, AffineMap ubMap) {<br>
assert(lbMap.getNumResults() == 1 && "expected single result bound map");<br>
assert(ubMap.getNumResults() == 1 && "expected single result bound map");<br>
@@ -391,7 +391,7 @@ static uint64_t getSliceIterationCount(<br>
// nest surrounding represented by slice loop bounds in 'slice'.<br>
// Returns true on success, false otherwise (if a non-constant trip count<br>
// was encountered).<br>
-// TODO(andydavis) Make this work with non-unit step loops.<br>
+// TODO: Make this work with non-unit step loops.<br>
static bool buildSliceTripCountMap(<br>
ComputationSliceState *slice,<br>
llvm::SmallDenseMap<Operation *, uint64_t, 8> *tripCountMap) {<br>
@@ -457,7 +457,7 @@ bool mlir::getFusionComputeCost(AffineForOp srcForOp, LoopNestStats &srcStats,<br>
auto *insertPointParent = slice->insertPoint->getParentOp();<br>
<br>
// The store and loads to this memref will disappear.<br>
- // TODO(andydavis) Add load coalescing to memref data flow opt pass.<br>
+ // TODO: Add load coalescing to memref data flow opt pass.<br>
if (storeLoadFwdGuaranteed) {<br>
// Subtract from operation count the loads/store we expect load/store<br>
// forwarding to remove.<br>
<br>
diff --git a/mlir/lib/Transforms/Utils/LoopUtils.cpp b/mlir/lib/Transforms/Utils/LoopUtils.cpp<br>
index 58807cf72128..249fa1cfdbc2 100644<br>
--- a/mlir/lib/Transforms/Utils/LoopUtils.cpp<br>
+++ b/mlir/lib/Transforms/Utils/LoopUtils.cpp<br>
@@ -149,7 +149,7 @@ static Value ceilDivPositive(OpBuilder &builder, Location loc, Value dividend,<br>
<br>
/// Promotes the loop body of a forOp to its containing block if the forOp<br>
/// was known to have a single iteration.<br>
-// TODO(bondhugula): extend this for arbitrary affine bounds.<br>
+// TODO: extend this for arbitrary affine bounds.<br>
LogicalResult mlir::promoteIfSingleIteration(AffineForOp forOp) {<br>
Optional<uint64_t> tripCount = getConstantTripCount(forOp);<br>
if (!tripCount || tripCount.getValue() != 1)<br>
@@ -529,7 +529,7 @@ LogicalResult mlir::loopUnrollByFactor(AffineForOp forOp,<br>
return failure();<br>
<br>
// If the trip count is lower than the unroll factor, no unrolled body.<br>
- // TODO(bondhugula): option to specify cleanup loop unrolling.<br>
+ // TODO: option to specify cleanup loop unrolling.<br>
Optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);<br>
if (mayBeConstantTripCount.hasValue() &&<br>
mayBeConstantTripCount.getValue() < unrollFactor)<br>
@@ -623,7 +623,7 @@ LogicalResult mlir::loopUnrollByFactor(scf::ForOp forOp,<br>
: boundsBuilder.create<ConstantIndexOp>(loc, stepUnrolledCst);<br>
} else {<br>
// Dynamic loop bounds computation.<br>
- // TODO(andydavis) Add dynamic asserts for negative lb/ub/step, or<br>
+ // TODO: Add dynamic asserts for negative lb/ub/step, or<br>
// consider using ceilDiv from AffineApplyExpander.<br>
auto lowerBound = forOp.lowerBound();<br>
auto upperBound = forOp.upperBound();<br>
@@ -720,7 +720,7 @@ LogicalResult mlir::loopUnrollJamByFactor(AffineForOp forOp,<br>
// Loops where both lower and upper bounds are multi-result maps won't be<br>
// unrolled (since the trip can't be expressed as an affine function in<br>
// general).<br>
- // TODO(mlir-team): this may not be common, but we could support the case<br>
+ // TODO: this may not be common, but we could support the case<br>
// where the lower bound is a multi-result map and the ub is a single result<br>
// one.<br>
if (forOp.getLowerBoundMap().getNumResults() != 1)<br>
@@ -1127,7 +1127,7 @@ static Loops stripmineSink(scf::ForOp forOp, Value factor,<br>
// Returns the new AffineForOps, nested immediately under `target`.<br>
template <typename ForType, typename SizeType><br>
static ForType stripmineSink(ForType forOp, SizeType factor, ForType target) {<br>
- // TODO(ntv): Use cheap structural assertions that targets are nested under<br>
+ // TODO: Use cheap structural assertions that targets are nested under<br>
// forOp and that targets are not nested under each other when DominanceInfo<br>
// exposes the capability. It seems overkill to construct a whole function<br>
// dominance tree at this point.<br>
@@ -1226,7 +1226,7 @@ static LogicalResult hoistOpsBetween(scf::ForOp outer, scf::ForOp inner) {<br>
continue;<br>
}<br>
// Skip if op has side effects.<br>
- // TODO(ntv): loads to immutable memory regions are ok.<br>
+ // TODO: loads to immutable memory regions are ok.<br>
if (!MemoryEffectOpInterface::hasNoEffect(&op)) {<br>
status = failure();<br>
continue;<br>
@@ -1294,7 +1294,7 @@ TileLoops mlir::extractFixedOuterLoops(scf::ForOp rootForOp,<br>
auto intraTile = tile(forOps, tileSizes, forOps.back());<br>
TileLoops tileLoops = std::make_pair(forOps, intraTile);<br>
<br>
- // TODO(ntv, zinenko) for now we just ignore the result of band isolation.<br>
+ // TODO: for now we just ignore the result of band isolation.<br>
// In the future, mapping decisions may be impacted by the ability to<br>
// isolate perfectly nested bands.<br>
tryIsolateBands(tileLoops);<br>
@@ -1322,7 +1322,7 @@ static LoopParams normalizeLoop(OpBuilder &boundsBuilder,<br>
// Compute the number of iterations the loop executes: ceildiv(ub - lb, step)<br>
// assuming the step is strictly positive. Update the bounds and the step<br>
// of the loop to go from 0 to the number of iterations, if necessary.<br>
- // TODO(zinenko): introduce support for negative steps or emit dynamic asserts<br>
+ // TODO: introduce support for negative steps or emit dynamic asserts<br>
// on step positivity, whatever gets implemented first.<br>
if (isZeroBased && isStepOne)<br>
return {/*lowerBound=*/lowerBound, /*upperBound=*/upperBound,<br>
@@ -1552,7 +1552,7 @@ findHighestBlockForPlacement(const MemRefRegion ®ion, Block &block,<br>
// symbolic/variant.<br>
auto it = enclosingFors.rbegin();<br>
for (auto e = enclosingFors.rend(); it != e; ++it) {<br>
- // TODO(bondhugula): also need to be checking this for regions symbols that<br>
+ // TODO: also need to be checking this for regions symbols that<br>
// aren't loop IVs, whether we are within their resp. defs' dominance scope.<br>
if (llvm::is_contained(symbols, it->getInductionVar()))<br>
break;<br>
@@ -1580,7 +1580,7 @@ struct StrideInfo {<br>
/// potentially multiple striding levels from outermost to innermost. For an<br>
/// n-dimensional region, there can be at most n-1 levels of striding<br>
/// successively nested.<br>
-// TODO(bondhugula): make this work with non-identity layout maps.<br>
+// TODO: make this work with non-identity layout maps.<br>
static void getMultiLevelStrides(const MemRefRegion ®ion,<br>
ArrayRef<int64_t> bufferShape,<br>
SmallVectorImpl<StrideInfo> *strideInfos) {<br>
@@ -1865,7 +1865,7 @@ static LogicalResult generateCopy(<br>
SmallVector<StrideInfo, 4> dmaStrideInfos;<br>
getMultiLevelStrides(region, fastBufferShape, &dmaStrideInfos);<br>
<br>
- // TODO(bondhugula): use all stride levels once DmaStartOp is extended for<br>
+ // TODO: use all stride levels once DmaStartOp is extended for<br>
// multi-level strides.<br>
if (dmaStrideInfos.size() > 1) {<br>
LLVM_DEBUG(llvm::dbgs() << "Only up to one level of stride supported\n");<br>
@@ -2120,7 +2120,7 @@ uint64_t mlir::affineDataCopyGenerate(Block::iterator begin,<br>
<br>
// Each memref has a single buffer associated with it irrespective of how<br>
// many load's and store's happen on it.<br>
- // TODO(bondhugula): in the future, when regions don't intersect and satisfy<br>
+ // TODO: in the future, when regions don't intersect and satisfy<br>
// other properties (based on load/store regions), we could consider<br>
// multiple buffers per memref.<br>
<br>
<br>
diff --git a/mlir/lib/Transforms/Utils/Utils.cpp b/mlir/lib/Transforms/Utils/Utils.cpp<br>
index 86bf4da806d9..5d6d58fc6939 100644<br>
--- a/mlir/lib/Transforms/Utils/Utils.cpp<br>
+++ b/mlir/lib/Transforms/Utils/Utils.cpp<br>
@@ -28,7 +28,7 @@ using namespace mlir;<br>
<br>
/// Return true if this operation dereferences one or more memref's.<br>
// Temporary utility: will be replaced when this is modeled through<br>
-// side-effects/op traits. TODO(b/117228571)<br>
+// side-effects/op traits. TODO<br>
static bool isMemRefDereferencingOp(Operation &op) {<br>
return isa<AffineReadOpInterface, AffineWriteOpInterface, AffineDmaStartOp,<br>
AffineDmaWaitOp>(op);<br>
@@ -83,7 +83,7 @@ LogicalResult mlir::replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,<br>
return success();<br>
<br>
if (usePositions.size() > 1) {<br>
- // TODO(mlir-team): extend it for this case when needed (rare).<br>
+ // TODO: extend it for this case when needed (rare).<br>
assert(false && "multiple dereferencing uses in a single op not supported");<br>
return failure();<br>
}<br>
@@ -162,7 +162,7 @@ LogicalResult mlir::replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,<br>
// Create new fully composed AffineMap for new op to be created.<br>
assert(newMapOperands.size() == newMemRefRank);<br>
auto newMap = builder.getMultiDimIdentityMap(newMemRefRank);<br>
- // TODO(b/136262594) Avoid creating/deleting temporary AffineApplyOps here.<br>
+ // TODO: Avoid creating/deleting temporary AffineApplyOps here.<br>
fullyComposeAffineMapAndOperands(&newMap, &newMapOperands);<br>
newMap = simplifyAffineMap(newMap);<br>
canonicalizeMapAndOperands(&newMap, &newMapOperands);<br>
<br>
diff --git a/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir b/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir<br>
index 273b22779d56..fa9a478c1d83 100644<br>
--- a/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir<br>
+++ b/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir<br>
@@ -77,7 +77,7 @@ gpu.module @test_module {<br>
// CHECK-LABEL: func @gpu_all_reduce_op()<br>
gpu.func @gpu_all_reduce_op() {<br>
%arg0 = constant 1.0 : f32<br>
- // TODO(csigg): Check full IR expansion once lowering has settled.<br>
+ // TODO: Check full IR expansion once lowering has settled.<br>
// CHECK: nvvm.shfl.sync.bfly<br>
// CHECK: nvvm.barrier0<br>
// CHECK: llvm.fadd<br>
@@ -93,7 +93,7 @@ gpu.module @test_module {<br>
// CHECK-LABEL: func @gpu_all_reduce_region()<br>
gpu.func @gpu_all_reduce_region() {<br>
%arg0 = constant 1 : i32<br>
- // TODO(csigg): Check full IR expansion once lowering has settled.<br>
+ // TODO: Check full IR expansion once lowering has settled.<br>
// CHECK: nvvm.shfl.sync.bfly<br>
// CHECK: nvvm.barrier0<br>
%result = "gpu.all_reduce"(%arg0) ({<br>
<br>
diff --git a/mlir/test/Conversion/GPUToSPIRV/if.mlir b/mlir/test/Conversion/GPUToSPIRV/if.mlir<br>
index 81a7f6d32b91..b7e11d74996b 100644<br>
--- a/mlir/test/Conversion/GPUToSPIRV/if.mlir<br>
+++ b/mlir/test/Conversion/GPUToSPIRV/if.mlir<br>
@@ -131,7 +131,7 @@ module attributes {<br>
store %0#1, %arg2[%j] : memref<10xf32><br>
gpu.return<br>
}<br>
- // TODO(thomasraoux): The transformation should only be legal if<br>
+ // TODO: The transformation should only be legal if<br>
// VariablePointer capability is supported. This test is still useful to<br>
// make sure we can handle scf op result with type change.<br>
// CHECK-LABEL: @simple_if_yield_type_change<br>
<br>
diff --git a/mlir/test/Dialect/Linalg/roundtrip.mlir b/mlir/test/Dialect/Linalg/roundtrip.mlir<br>
index f210b185331c..9e6c27547930 100644<br>
--- a/mlir/test/Dialect/Linalg/roundtrip.mlir<br>
+++ b/mlir/test/Dialect/Linalg/roundtrip.mlir<br>
@@ -1,7 +1,7 @@<br>
// RUN: mlir-opt -split-input-file %s | FileCheck %s<br>
// | mlir-opt | FileCheck %s<br>
<br>
-// TODO(pifon): Re-enable LLVM lowering test after IndexedGenericOp is lowered.<br>
+// TODO: Re-enable LLVM lowering test after IndexedGenericOp is lowered.<br>
//<br>
// Test that we can lower all the way to LLVM without crashing, don't check results here.<br>
// DISABLED: mlir-opt %s --convert-linalg-to-llvm -o=/dev/null 2>&1<br>
<br>
diff --git a/mlir/test/Dialect/SPIRV/Serialization/constant.mlir b/mlir/test/Dialect/SPIRV/Serialization/constant.mlir<br>
index a276e4ee9781..520669262e12 100644<br>
--- a/mlir/test/Dialect/SPIRV/Serialization/constant.mlir<br>
+++ b/mlir/test/Dialect/SPIRV/Serialization/constant.mlir<br>
@@ -108,7 +108,7 @@ spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {<br>
<br>
// CHECK-LABEL: @double_const<br>
spv.func @double_const() -> () "None" {<br>
- // TODO(antiagainst): test range boundary values<br>
+ // TODO: test range boundary values<br>
// CHECK: spv.constant 1.024000e+03 : f64<br>
%0 = spv.constant 1024. : f64<br>
// CHECK: spv.constant -1.024000e+03 : f64<br>
<br>
diff --git a/mlir/test/Dialect/SPIRV/canonicalize.mlir b/mlir/test/Dialect/SPIRV/canonicalize.mlir<br>
index 2b719fd7219d..ad129c2f0825 100644<br>
--- a/mlir/test/Dialect/SPIRV/canonicalize.mlir<br>
+++ b/mlir/test/Dialect/SPIRV/canonicalize.mlir<br>
@@ -141,7 +141,7 @@ func @extract_from_not_constant() -> i32 {<br>
// spv.constant<br>
//===----------------------------------------------------------------------===//<br>
<br>
-// TODO(antiagainst): test constants in <br>
diff erent blocks<br>
+// TODO: test constants in <br>
diff erent blocks<br>
<br>
func @deduplicate_scalar_constant() -> (i32, i32) {<br>
// CHECK: %[[CST:.*]] = spv.constant 42 : i32<br>
<br>
diff --git a/mlir/test/Dialect/SPIRV/structure-ops.mlir b/mlir/test/Dialect/SPIRV/structure-ops.mlir<br>
index 93df070f0a2a..2d62f64b2479 100644<br>
--- a/mlir/test/Dialect/SPIRV/structure-ops.mlir<br>
+++ b/mlir/test/Dialect/SPIRV/structure-ops.mlir<br>
@@ -175,7 +175,7 @@ spv.module Logical GLSL450 {<br>
spv.EntryPoint "GLCompute" @do_something<br>
}<br>
<br>
-/// TODO(ravishankarm) : Add a test that verifies an error is thrown<br>
+/// TODO: Add a test that verifies an error is thrown<br>
/// when interface entries of EntryPointOp are not<br>
/// spv.Variables. There is currently no other op that has a spv.ptr<br>
/// return type<br>
<br>
diff --git a/mlir/test/Dialect/SPIRV/types.mlir b/mlir/test/Dialect/SPIRV/types.mlir<br>
index d5eb073c9aa5..810e00b5dedd 100644<br>
--- a/mlir/test/Dialect/SPIRV/types.mlir<br>
+++ b/mlir/test/Dialect/SPIRV/types.mlir<br>
@@ -1,6 +1,6 @@<br>
// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s<br>
<br>
-// TODO(b/133530217): Add more tests after switching to the generic parser.<br>
+// TODO: Add more tests after switching to the generic parser.<br>
<br>
//===----------------------------------------------------------------------===//<br>
// ArrayType<br>
<br>
diff --git a/mlir/test/Dialect/Vector/vector-flat-transforms.mlir b/mlir/test/Dialect/Vector/vector-flat-transforms.mlir<br>
index 6a1e6ee85a7d..c07d651d985e 100644<br>
--- a/mlir/test/Dialect/Vector/vector-flat-transforms.mlir<br>
+++ b/mlir/test/Dialect/Vector/vector-flat-transforms.mlir<br>
@@ -2,10 +2,9 @@<br>
<br>
// Tests for lowering 2-D vector.transpose into vector.flat_transpose.<br>
//<br>
-// TODO(ajcbik,ntv): having ShapeCastOp2DDownCastRewritePattern and<br>
-// ShapeCastOp2DUpCastRewritePattern too early in<br>
-// the greedy rewriting patterns misses opportunities<br>
-// to fold shape casts!<br>
+// TODO: having ShapeCastOp2DDownCastRewritePattern and<br>
+// ShapeCastOp2DUpCastRewritePattern too early in the greedy rewriting<br>
+// patterns misses opportunities to fold shape casts!<br>
<br>
// No shape cast folding expected.<br>
//<br>
<br>
diff --git a/mlir/test/Dialect/Vector/vector-transforms.mlir b/mlir/test/Dialect/Vector/vector-transforms.mlir<br>
index 0bd6c3c43b59..a32fa4a05649 100644<br>
--- a/mlir/test/Dialect/Vector/vector-transforms.mlir<br>
+++ b/mlir/test/Dialect/Vector/vector-transforms.mlir<br>
@@ -281,7 +281,7 @@ func @contraction4x4_ikj_xfer_read(%arg0 : memref<4x2xf32>,<br>
return<br>
}<br>
<br>
-// TODO(andydavis) Update test with VTR split transform.<br>
+// TODO: Update test with VTR split transform.<br>
// CHECK-LABEL: func @vector_transfers<br>
// CHECK-COUNT-8: vector.transfer_read<br>
// CHECK-COUNT-4: addf<br>
<br>
diff --git a/mlir/test/IR/invalid-affinemap.mlir b/mlir/test/IR/invalid-affinemap.mlir<br>
index 741ad9a3dfdf..9377824f006a 100644<br>
--- a/mlir/test/IR/invalid-affinemap.mlir<br>
+++ b/mlir/test/IR/invalid-affinemap.mlir<br>
@@ -96,7 +96,7 @@<br>
// -----<br>
#hello_world = affine_map<(i, j) -> (i, 3*d0 + )> // expected-error {{use of undeclared identifier}}<br>
<br>
-// TODO(bondhugula): Add more tests; coverage of error messages emitted not complete<br>
+// TODO: Add more tests; coverage of error messages emitted not complete<br>
<br>
// -----<br>
#ABC = affine_map<(i,j) -> (i+j)><br>
<br>
diff --git a/mlir/test/IR/invalid.mlir b/mlir/test/IR/invalid.mlir<br>
index f025fdf3ba4d..19bf53783869 100644<br>
--- a/mlir/test/IR/invalid.mlir<br>
+++ b/mlir/test/IR/invalid.mlir<br>
@@ -290,7 +290,7 @@ func @invalid_if_conditional6() {<br>
}<br>
<br>
// -----<br>
-// TODO (support affine.if (1)?<br>
+// TODO: support affine.if (1)?<br>
func @invalid_if_conditional7() {<br>
affine.for %i = 1 to 10 {<br>
affine.if affine_set<(i) : (1)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}<br>
<br>
diff --git a/mlir/test/Transforms/loop-fusion.mlir b/mlir/test/Transforms/loop-fusion.mlir<br>
index 51d2fb42a1c1..7d91e780e9ed 100644<br>
--- a/mlir/test/Transforms/loop-fusion.mlir<br>
+++ b/mlir/test/Transforms/loop-fusion.mlir<br>
@@ -1,12 +1,12 @@<br>
// RUN: mlir-opt -allow-unregistered-dialect %s -affine-loop-fusion -split-input-file | FileCheck %s<br>
// RUN: mlir-opt -allow-unregistered-dialect %s -affine-loop-fusion="fusion-maximal" -split-input-file | FileCheck %s --check-prefix=MAXIMAL<br>
<br>
-// TODO(andydavis) Add more tests:<br>
+// TODO: Add more tests:<br>
// *) Add nested fusion test cases when non-constant loop bound support is<br>
// added to iteration domain in dependence check.<br>
// *) Add a test w/ floordiv/ceildiv/mod when supported in dependence check.<br>
// *) Add tests which check fused computation slice indexing and loop bounds.<br>
-// TODO(andydavis) Test clean up: move memref allocs to func args.<br>
+// TODO: Test clean up: move memref allocs to func args.<br>
<br>
// -----<br>
<br>
@@ -317,7 +317,7 @@ func @should_fuse_producer_consumer() {<br>
}<br>
// Fusing loop %i0 to %i2 would violate the WAW dependence between %i0 and<br>
// %i1, but OK to fuse %i1 into %i2.<br>
- // TODO(andydavis) When the fusion pass is run to a fixed-point, it should<br>
+ // TODO: When the fusion pass is run to a fixed-point, it should<br>
// fuse all three of these loop nests.<br>
// CHECK: alloc() : memref<1xf32><br>
// CHECK: affine.for %{{.*}} = 0 to 10 {<br>
<br>
diff --git a/mlir/test/Transforms/memref-dependence-check.mlir b/mlir/test/Transforms/memref-dependence-check.mlir<br>
index 65af899c726c..154dcf79c114 100644<br>
--- a/mlir/test/Transforms/memref-dependence-check.mlir<br>
+++ b/mlir/test/Transforms/memref-dependence-check.mlir<br>
@@ -766,7 +766,7 @@ func @delinearize_mod_floordiv() {<br>
// expected-remark@above {{dependence from 1 to 2 at depth 1 = false}}<br>
// expected-remark@above {{dependence from 1 to 2 at depth 2 = false}}<br>
// expected-remark@above {{dependence from 1 to 2 at depth 3 = false}}<br>
-// TODO(andydavis): the dep tester shouldn't be printing out these messages<br>
+// TODO: the dep tester shouldn't be printing out these messages<br>
// below; they are redundant.<br>
affine.store %v0, %out[%ii, %jj] : memref<64x9xi32><br>
// expected-remark@above {{dependence from 2 to 0 at depth 1 = false}}<br>
@@ -781,7 +781,7 @@ func @delinearize_mod_floordiv() {<br>
return<br>
}<br>
<br>
-// TODO(bondhugula): add more test cases involving mod's/div's.<br>
+// TODO: add more test cases involving mod's/div's.<br>
<br>
// -----<br>
<br>
<br>
diff --git a/mlir/test/lib/DeclarativeTransforms/TestVectorTransformPatterns.td b/mlir/test/lib/DeclarativeTransforms/TestVectorTransformPatterns.td<br>
index 49a3499b0bad..2c6ca1a05733 100644<br>
--- a/mlir/test/lib/DeclarativeTransforms/TestVectorTransformPatterns.td<br>
+++ b/mlir/test/lib/DeclarativeTransforms/TestVectorTransformPatterns.td<br>
@@ -26,7 +26,7 @@ def : Pat<(AddFOp:$op_results $a, $b),<br>
(UnrollVectorOp<[2, 2]> $op_results, $a, $b),<br>
[(Constraint<HasShape<[4, 4]>> $a)]>;<br>
<br>
-// TODO(andydavis) Add Constraints on lhs/rhs shapes.<br>
+// TODO: Add Constraints on lhs/rhs shapes.<br>
def : Pat<(Vector_ContractionOp:$op_results $a, $b, $c, $masks, $attr0, $attr1),<br>
(UnrollVectorOp<[2, 2, 2]> $op_results, $a, $b, $c),<br>
[(Constraint<HasShape<[4, 4]>> $c)]>;<br>
<br>
diff --git a/mlir/test/lib/Dialect/Test/TestPatterns.cpp b/mlir/test/lib/Dialect/Test/TestPatterns.cpp<br>
index f44b987f17cb..c471cd3ead3e 100644<br>
--- a/mlir/test/lib/Dialect/Test/TestPatterns.cpp<br>
+++ b/mlir/test/lib/Dialect/Test/TestPatterns.cpp<br>
@@ -111,7 +111,7 @@ static void invokeCreateWithInferredReturnType(Operation *op) {<br>
context, llvm::None, values, op->getAttrDictionary(),<br>
op->getRegions(), inferredReturnTypes))) {<br>
OperationState state(location, OpTy::getOperationName());<br>
- // TODO(jpienaar): Expand to regions.<br>
+ // TODO: Expand to regions.<br>
OpTy::build(b, state, values, op->getAttrs());<br>
(void)b.createOperation(state);<br>
}<br>
<br>
diff --git a/mlir/test/lib/Transforms/TestInlining.cpp b/mlir/test/lib/Transforms/TestInlining.cpp<br>
index 1cc762836b3c..27c0d0846269 100644<br>
--- a/mlir/test/lib/Transforms/TestInlining.cpp<br>
+++ b/mlir/test/lib/Transforms/TestInlining.cpp<br>
@@ -6,7 +6,7 @@<br>
//<br>
//===----------------------------------------------------------------------===//<br>
//<br>
-// TODO(riverriddle) This pass is only necessary because the main inlining pass<br>
+// TODO: This pass is only necessary because the main inlining pass<br>
// has no abstracted away the call+callee relationship. When the inlining<br>
// interface has this support, this pass should be removed.<br>
//<br>
<br>
diff --git a/mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp b/mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp<br>
index 087ea4fdde94..4ae9e505cab3 100644<br>
--- a/mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp<br>
+++ b/mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp<br>
@@ -41,7 +41,7 @@ void TestMemRefBoundCheck::runOnFunction() {<br>
.Case<AffineReadOpInterface, AffineWriteOpInterface>(<br>
[](auto op) { boundCheckLoadOrStoreOp(op); });<br>
<br>
- // TODO(bondhugula): do this for DMA ops as well.<br>
+ // TODO: do this for DMA ops as well.<br>
});<br>
}<br>
<br>
<br>
diff --git a/mlir/test/lib/Transforms/TestMemRefDependenceCheck.cpp b/mlir/test/lib/Transforms/TestMemRefDependenceCheck.cpp<br>
index 7a67bef93bc2..787c92737daf 100644<br>
--- a/mlir/test/lib/Transforms/TestMemRefDependenceCheck.cpp<br>
+++ b/mlir/test/lib/Transforms/TestMemRefDependenceCheck.cpp<br>
@@ -25,7 +25,7 @@ using namespace mlir;<br>
<br>
namespace {<br>
<br>
-// TODO(andydavis) Add common surrounding loop depth-wise dependence checks.<br>
+// TODO: Add common surrounding loop depth-wise dependence checks.<br>
/// Checks dependences between all pairs of memref accesses in a Function.<br>
struct TestMemRefDependenceCheck<br>
: public PassWrapper<TestMemRefDependenceCheck, FunctionPass> {<br>
@@ -85,7 +85,7 @@ static void checkDependences(ArrayRef<Operation *> loadsAndStores) {<br>
&dependenceComponents);<br>
assert(result.value != DependenceResult::Failure);<br>
bool ret = hasDependence(result);<br>
- // TODO(andydavis) Print dependence type (i.e. RAW, etc) and print<br>
+ // TODO: Print dependence type (i.e. RAW, etc) and print<br>
// distance vectors as: ([2, 3], [0, 10]). Also, shorten distance<br>
// vectors from ([1, 1], [3, 3]) to (1, 3).<br>
srcOpInst->emitRemark("dependence from ")<br>
<br>
diff --git a/mlir/tools/mlir-rocm-runner/mlir-rocm-runner.cpp b/mlir/tools/mlir-rocm-runner/mlir-rocm-runner.cpp<br>
index 8c23713ad65d..d61cb2d98809 100644<br>
--- a/mlir/tools/mlir-rocm-runner/mlir-rocm-runner.cpp<br>
+++ b/mlir/tools/mlir-rocm-runner/mlir-rocm-runner.cpp<br>
@@ -198,7 +198,7 @@ static LogicalResult createHsaco(const Blob &isaBlob, StringRef name,<br>
<br>
static std::unique_ptr<llvm::Module> compileModuleToROCDLIR(Operation *m) {<br>
auto llvmModule = translateModuleToROCDLIR(m);<br>
- // TODO(whchung): Link with ROCm-Device-Libs in case needed (ex: the Module<br>
+ // TODO: Link with ROCm-Device-Libs in case needed (ex: the Module<br>
// depends on math functions).<br>
return llvmModule;<br>
}<br>
<br>
diff --git a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp<br>
index f391f4be9160..dcf40691e17f 100644<br>
--- a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp<br>
+++ b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp<br>
@@ -319,7 +319,7 @@ class OpEmitter {<br>
<br>
private:<br>
// The TableGen record for this op.<br>
- // TODO(antiagainst,zinenko): OpEmitter should not have a Record directly,<br>
+ // TODO: OpEmitter should not have a Record directly,<br>
// it should rather go through the Operator for better abstraction.<br>
const Record &def;<br>
<br>
@@ -915,9 +915,9 @@ void OpEmitter::genSeparateArgParamBuilder() {<br>
<br>
if (inferType) {<br>
// Generate builder that infers type too.<br>
- // TODO(jpienaar): Subsume this with general checking if type can be<br>
+ // TODO: Subsume this with general checking if type can be<br>
// inferred automatically.<br>
- // TODO(jpienaar): Expand to handle regions.<br>
+ // TODO: Expand to handle regions.<br>
body << formatv(R"(<br>
::llvm::SmallVector<::mlir::Type, 2> inferredReturnTypes;<br>
if (succeeded({0}::inferReturnTypes(odsBuilder.getContext(),<br>
@@ -1006,7 +1006,7 @@ void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {<br>
}<br>
<br>
void OpEmitter::genInferredTypeCollectiveParamBuilder() {<br>
- // TODO(jpienaar): Expand to support regions.<br>
+ // TODO: Expand to support regions.<br>
const char *params =<br>
"::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &{0}, "<br>
"::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> "<br>
@@ -1119,7 +1119,7 @@ void OpEmitter::genUseAttrAsResultTypeBuilder() {<br>
<br>
void OpEmitter::genBuilder() {<br>
// Handle custom builders if provided.<br>
- // TODO(antiagainst): Create wrapper class for OpBuilder to hide the native<br>
+ // TODO: Create wrapper class for OpBuilder to hide the native<br>
// TableGen API calls here.<br>
{<br>
auto *listInit = dyn_cast_or_null<ListInit>(def.getValueInit("builders"));<br>
@@ -1215,7 +1215,7 @@ void OpEmitter::genCollectiveParamBuilder() {<br>
body << " " << builderOpState << ".addTypes(resultTypes);\n";<br>
<br>
// Generate builder that infers type too.<br>
- // TODO(jpienaar): Expand to handle regions and successors.<br>
+ // TODO: Expand to handle regions and successors.<br>
if (canInferType(op) && op.getNumSuccessors() == 0)<br>
genInferredTypeCollectiveParamBuilder();<br>
}<br>
@@ -1279,7 +1279,7 @@ void OpEmitter::buildParamList(std::string ¶mList,<br>
// Creating an APInt requires us to provide bitwidth, value, and<br>
// signedness, which is complicated compared to others. Similarly<br>
// for APFloat.<br>
- // TODO(b/144412160) Adjust the 'returnType' field of such attributes<br>
+ // TODO: Adjust the 'returnType' field of such attributes<br>
// to support them.<br>
StringRef retType = namedAttr->attr.getReturnType();<br>
if (retType == "::llvm::APInt" || retType == "::llvm::APFloat")<br>
<br>
diff --git a/mlir/tools/mlir-tblgen/OpDocGen.cpp b/mlir/tools/mlir-tblgen/OpDocGen.cpp<br>
index a432b4a2f21c..df78556c1c77 100644<br>
--- a/mlir/tools/mlir-tblgen/OpDocGen.cpp<br>
+++ b/mlir/tools/mlir-tblgen/OpDocGen.cpp<br>
@@ -197,7 +197,7 @@ static void emitDialectDoc(const Dialect &dialect, ArrayRef<Operator> ops,<br>
<br>
os << "[TOC]\n\n";<br>
<br>
- // TODO(antiagainst): Add link between use and def for types<br>
+ // TODO: Add link between use and def for types<br>
if (!types.empty()) {<br>
os << "## Type definition\n\n";<br>
for (const Type &type : types)<br>
<br>
diff --git a/mlir/tools/mlir-tblgen/OpFormatGen.cpp b/mlir/tools/mlir-tblgen/OpFormatGen.cpp<br>
index 1cfcf32f8c06..3fcbeeff1e6f 100644<br>
--- a/mlir/tools/mlir-tblgen/OpFormatGen.cpp<br>
+++ b/mlir/tools/mlir-tblgen/OpFormatGen.cpp<br>
@@ -2118,7 +2118,7 @@ FormatParser::parseTypeDirectiveOperand(std::unique_ptr<Element> &element) {<br>
//===----------------------------------------------------------------------===//<br>
<br>
void mlir::tblgen::generateOpFormat(const Operator &constOp, OpClass &opClass) {<br>
- // TODO(riverriddle) Operator doesn't expose all necessary functionality via<br>
+ // TODO: Operator doesn't expose all necessary functionality via<br>
// the const interface.<br>
Operator &op = const_cast<Operator &>(constOp);<br>
if (!op.hasAssemblyFormat())<br>
<br>
diff --git a/mlir/tools/mlir-tblgen/RewriterGen.cpp b/mlir/tools/mlir-tblgen/RewriterGen.cpp<br>
index 37af7d222753..fc67ec4b8c17 100644<br>
--- a/mlir/tools/mlir-tblgen/RewriterGen.cpp<br>
+++ b/mlir/tools/mlir-tblgen/RewriterGen.cpp<br>
@@ -204,7 +204,7 @@ std::string PatternEmitter::handleConstantAttr(Attribute attr,<br>
PrintFatalError(loc, "Attribute " + attr.getAttrDefName() +<br>
" does not have the 'constBuilderCall' field");<br>
<br>
- // TODO(jpienaar): Verify the constants here<br>
+ // TODO: Verify the constants here<br>
return std::string(tgfmt(attr.getConstBuilderTemplate(), &fmtCtx, value));<br>
}<br>
<br>
@@ -343,7 +343,7 @@ void PatternEmitter::emitAttributeMatch(DagNode tree, int argIndex, int depth,<br>
"(void)tblgen_attr;\n",<br>
depth, attr.getStorageType(), namedAttr->name);<br>
<br>
- // TODO(antiagainst): This should use getter method to avoid duplication.<br>
+ // TODO: This should use getter method to avoid duplication.<br>
if (attr.hasDefaultValue()) {<br>
os.indent(indent) << "if (!tblgen_attr) tblgen_attr = "<br>
<< std::string(tgfmt(attr.getConstBuilderTemplate(),<br>
@@ -429,7 +429,7 @@ void PatternEmitter::emitMatchLogic(DagNode tree) {<br>
PrintFatalError(<br>
loc, "cannot use AttrConstraint in Pattern multi-entity constraints");<br>
} else {<br>
- // TODO(b/138794486): replace formatv arguments with the exact specified<br>
+ // TODO: replace formatv arguments with the exact specified<br>
// args.<br>
if (entities.size() > 4) {<br>
PrintFatalError(loc, "only support up to 4-entity constraints now");<br>
@@ -526,7 +526,7 @@ void PatternEmitter::emit(StringRef rewriteName) {<br>
auto &info = symbolInfoPair.getValue();<br>
os.indent(4) << info.getVarDecl(symbol);<br>
}<br>
- // TODO(jpienaar): capture ops with consistent numbering so that it can be<br>
+ // TODO: capture ops with consistent numbering so that it can be<br>
// reused for fused loc.<br>
os.indent(4) << formatv("::mlir::Operation *tblgen_ops[{0}];\n\n",<br>
pattern.getSourcePattern().getNumOps());<br>
@@ -619,7 +619,7 @@ void PatternEmitter::emitRewriteLogic() {<br>
// `{0}` resolves to an `Operation::result_range` as well as cases that<br>
// are not iterable (e.g. vector that gets wrapped in additional braces by<br>
// RewriterGen).<br>
- // TODO(b/147096809): Revisit the need for materializing a vector.<br>
+ // TODO: Revisit the need for materializing a vector.<br>
os << symbolInfoMap.getAllRangeUse(<br>
val,<br>
" for (auto v : ::llvm::SmallVector<::mlir::Value, 4>{ {0} }) {{ "<br>
@@ -771,7 +771,7 @@ std::string PatternEmitter::handleReplaceWithNativeCodeCall(DagNode tree) {<br>
LLVM_DEBUG(llvm::dbgs() << '\n');<br>
<br>
auto fmt = tree.getNativeCodeTemplate();<br>
- // TODO(b/138794486): replace formatv arguments with the exact specified args.<br>
+ // TODO: replace formatv arguments with the exact specified args.<br>
SmallVector<std::string, 8> attrs(8);<br>
if (tree.getNumArgs() > 8) {<br>
PrintFatalError(loc, "unsupported NativeCodeCall argument numbers: " +<br>
@@ -797,7 +797,7 @@ int PatternEmitter::getNodeValueCount(DagNode node) {<br>
// Otherwise this is an unbound op; we will use all its results.<br>
return pattern.getDialectOp(node).getNumResults();<br>
}<br>
- // TODO(antiagainst): This considers all NativeCodeCall as returning one<br>
+ // TODO: This considers all NativeCodeCall as returning one<br>
// value. Enhance if multi-value ones are needed.<br>
return 1;<br>
}<br>
@@ -1026,7 +1026,7 @@ void PatternEmitter::supplyValuesForOpArgs(<br>
// The argument in the result DAG pattern.<br>
auto patArgName = node.getArgName(argIndex);<br>
if (leaf.isConstantAttr() || leaf.isEnumAttrCase()) {<br>
- // TODO(jpienaar): Refactor out into map to avoid recomputing these.<br>
+ // TODO: Refactor out into map to avoid recomputing these.<br>
if (!opArg.is<NamedAttribute *>())<br>
PrintFatalError(loc, Twine("expected attribute ") + Twine(argIndex));<br>
if (!patArgName.empty())<br>
<br>
diff --git a/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp b/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp<br>
index 37a2dabb0981..21f7349763db 100644<br>
--- a/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp<br>
+++ b/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp<br>
@@ -1283,7 +1283,7 @@ static void emitAvailabilityImpl(const Operator &srcOp, raw_ostream &os) {<br>
os << formatv(" auto tblgen_instance = {0}::{1}(tblgen_attrVal);\n",<br>
enumAttr->getCppNamespace(), avail.getQueryFnName());<br>
os << " if (tblgen_instance) "<br>
- // TODO(antiagainst): use `avail.getMergeCode()` here once ODS supports<br>
+ // TODO` here once ODS supports<br>
// dialect-specific contents so that we can use not implementing the<br>
// availability interface as indication of no requirements.<br>
<< std::string(tgfmt(caseSpecs.front().second.getMergeActionCode(),<br>
<br>
diff --git a/mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp b/mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp<br>
index 70812d2168fc..42f8be45135b 100644<br>
--- a/mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp<br>
+++ b/mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp<br>
@@ -15,7 +15,7 @@<br>
<br>
#include <chrono><br>
#include <cstring><br>
-// TODO(antiagainst): It's generally bad to access stdout/stderr in a library.<br>
+// TODO: It's generally bad to access stdout/stderr in a library.<br>
// Figure out a better way for error reporting.<br>
#include <iomanip><br>
#include <iostream><br>
@@ -261,7 +261,7 @@ LogicalResult VulkanRuntime::createDevice() {<br>
RETURN_ON_VULKAN_ERROR(physicalDeviceCount ? VK_SUCCESS : VK_INCOMPLETE,<br>
"physicalDeviceCount");<br>
<br>
- // TODO(denis0x0D): find the best device.<br>
+ // TODO: find the best device.<br>
physicalDevice = physicalDevices.front();<br>
if (failed(getBestComputeQueue()))<br>
return failure();<br>
<br>
diff --git a/mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp b/mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp<br>
index bfefebeefac3..31fc0e426e24 100644<br>
--- a/mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp<br>
+++ b/mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp<br>
@@ -54,7 +54,7 @@ class DeserializationTest : public ::testing::Test {<br>
void expectDiagnostic(StringRef errorMessage) {<br>
ASSERT_NE(nullptr, diagnostic.get());<br>
<br>
- // TODO(antiagainst): check error location too.<br>
+ // TODO: check error location too.<br>
EXPECT_THAT(diagnostic->str(), StrEq(std::string(errorMessage)));<br>
}<br>
<br>
<br>
diff --git a/mlir/utils/spirv/gen_spirv_dialect.py b/mlir/utils/spirv/gen_spirv_dialect.py<br>
index 19bd7cdfef06..159d8651223b 100755<br>
--- a/mlir/utils/spirv/gen_spirv_dialect.py<br>
+++ b/mlir/utils/spirv/gen_spirv_dialect.py<br>
@@ -255,7 +255,7 @@ def get_availability_spec(enum_case, capability_mapping, for_op, for_cap):<br>
min_version = ''<br>
elif min_version:<br>
min_version = 'MinVersion<SPV_V_{}>'.format(min_version.replace('.', '_'))<br>
- # TODO(antiagainst): delete this once ODS can support dialect-specific content<br>
+ # TODO: delete this once ODS can support dialect-specific content<br>
# and we can use omission to mean no requirements.<br>
if for_op and not min_version:<br>
min_version = DEFAULT_MIN_VERSION<br>
@@ -263,7 +263,7 @@ def get_availability_spec(enum_case, capability_mapping, for_op, for_cap):<br>
max_version = enum_case.get('lastVersion', '')<br>
if max_version:<br>
max_version = 'MaxVersion<SPV_V_{}>'.format(max_version.replace('.', '_'))<br>
- # TODO(antiagainst): delete this once ODS can support dialect-specific content<br>
+ # TODO: delete this once ODS can support dialect-specific content<br>
# and we can use omission to mean no requirements.<br>
if for_op and not max_version:<br>
max_version = DEFAULT_MAX_VERSION<br>
@@ -278,7 +278,7 @@ def get_availability_spec(enum_case, capability_mapping, for_op, for_cap):<br>
# a core symbol since the given version, rather than a minimal version<br>
# requirement.<br>
min_version = DEFAULT_MIN_VERSION if for_op else ''<br>
- # TODO(antiagainst): delete this once ODS can support dialect-specific content<br>
+ # TODO: delete this once ODS can support dialect-specific content<br>
# and we can use omission to mean no requirements.<br>
if for_op and not exts:<br>
exts = DEFAULT_EXT<br>
@@ -305,7 +305,7 @@ def get_availability_spec(enum_case, capability_mapping, for_op, for_cap):<br>
else:<br>
caps = 'Capability<[{}]>'.format(', '.join(prefixed_caps))<br>
implies = ''<br>
- # TODO(antiagainst): delete this once ODS can support dialect-specific content<br>
+ # TODO: delete this once ODS can support dialect-specific content<br>
# and we can use omission to mean no requirements.<br>
if for_op and not caps:<br>
caps = DEFAULT_CAP<br>
@@ -621,7 +621,7 @@ def map_spec_operand_to_ods_argument(operand):<br>
else:<br>
arg_type = 'Variadic<SPV_Type>'<br>
elif kind == 'IdMemorySemantics' or kind == 'IdScope':<br>
- # TODO(antiagainst): Need to further constrain 'IdMemorySemantics'<br>
+ # TODO: Need to further constrain 'IdMemorySemantics'<br>
# and 'IdScope' given that they should be generated from OpConstant.<br>
assert quantifier == '', ('unexpected to have optional/variadic memory '<br>
'semantics or scope <id>')<br>
<br>
<br>
<br>
_______________________________________________<br>
Mlir-commits mailing list<br>
<a href="mailto:Mlir-commits@lists.llvm.org" target="_blank">Mlir-commits@lists.llvm.org</a><br>
<a href="https://lists.llvm.org/cgi-bin/mailman/listinfo/mlir-commits" rel="noreferrer" target="_blank">https://lists.llvm.org/cgi-bin/mailman/listinfo/mlir-commits</a><br>
</blockquote></div>