MLIR  19.0.0git
Value.cpp
Go to the documentation of this file.
1 //===- Value.cpp - MLIR Value Classes -------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "mlir/IR/Value.h"
10 #include "mlir/IR/Block.h"
11 #include "mlir/IR/BuiltinTypes.h"
12 #include "mlir/IR/Operation.h"
13 #include "llvm/ADT/SmallPtrSet.h"
14 
15 using namespace mlir;
16 using namespace mlir::detail;
17 
18 /// If this value is the result of an Operation, return the operation that
19 /// defines it.
21  if (auto result = llvm::dyn_cast<OpResult>(*this))
22  return result.getOwner();
23  return nullptr;
24 }
25 
27  if (auto *op = getDefiningOp())
28  return op->getLoc();
29 
30  return llvm::cast<BlockArgument>(*this).getLoc();
31 }
32 
34  if (auto *op = getDefiningOp())
35  return op->setLoc(loc);
36 
37  return llvm::cast<BlockArgument>(*this).setLoc(loc);
38 }
39 
40 /// Return the Region in which this Value is defined.
42  if (auto *op = getDefiningOp())
43  return op->getParentRegion();
44  return llvm::cast<BlockArgument>(*this).getOwner()->getParent();
45 }
46 
47 /// Return the Block in which this Value is defined.
49  if (Operation *op = getDefiningOp())
50  return op->getBlock();
51  return llvm::cast<BlockArgument>(*this).getOwner();
52 }
53 
54 //===----------------------------------------------------------------------===//
55 // Value::UseLists
56 //===----------------------------------------------------------------------===//
57 
58 /// Replace all uses of 'this' value with the new value, updating anything in
59 /// the IR that uses 'this' to use the other value instead except if the user is
60 /// listed in 'exceptions' .
62  Value newValue, const SmallPtrSetImpl<Operation *> &exceptions) {
63  for (OpOperand &use : llvm::make_early_inc_range(getUses())) {
64  if (exceptions.count(use.getOwner()) == 0)
65  use.set(newValue);
66  }
67 }
68 
69 /// Replace all uses of 'this' value with 'newValue', updating anything in the
70 /// IR that uses 'this' to use the other value instead except if the user is
71 /// 'exceptedUser'.
72 void Value::replaceAllUsesExcept(Value newValue, Operation *exceptedUser) {
73  for (OpOperand &use : llvm::make_early_inc_range(getUses())) {
74  if (use.getOwner() != exceptedUser)
75  use.set(newValue);
76  }
77 }
78 
79 /// Replace all uses of 'this' value with 'newValue' if the given callback
80 /// returns true.
82  function_ref<bool(OpOperand &)> shouldReplace) {
83  for (OpOperand &use : llvm::make_early_inc_range(getUses()))
84  if (shouldReplace(use))
85  use.set(newValue);
86 }
87 
88 /// Returns true if the value is used outside of the given block.
89 bool Value::isUsedOutsideOfBlock(Block *block) const {
90  return llvm::any_of(getUsers(), [block](Operation *user) {
91  return user->getBlock() != block;
92  });
93 }
94 
95 /// Shuffles the use-list order according to the provided indices.
97  getImpl()->shuffleUseList(indices);
98 }
99 
100 //===----------------------------------------------------------------------===//
101 // OpResult
102 //===----------------------------------------------------------------------===//
103 
104 /// Returns the parent operation of this trailing result.
106  // We need to do some arithmetic to get the operation pointer. Results are
107  // stored in reverse order before the operation, so move the trailing owner up
108  // to the start of the array. A rough diagram of the memory layout is:
109  //
110  // | Out-of-Line results | Inline results | Operation |
111  //
112  // Given that the results are reverse order we use the result number to know
113  // how far to jump to get to the operation. So if we are currently the 0th
114  // result, the layout would be:
115  //
116  // | Inline result 0 | Operation
117  //
118  // ^-- To get the base address of the operation, we add the result count + 1.
119  if (const auto *result = dyn_cast<InlineOpResult>(this)) {
120  result += result->getResultNumber() + 1;
121  return reinterpret_cast<Operation *>(const_cast<InlineOpResult *>(result));
122  }
123 
124  // Out-of-line results are stored in an array just before the inline results.
125  const OutOfLineOpResult *outOfLineIt = (const OutOfLineOpResult *)(this);
126  outOfLineIt += (outOfLineIt->outOfLineIndex + 1);
127 
128  // Move the owner past the inline results to get to the operation.
129  const auto *inlineIt = reinterpret_cast<const InlineOpResult *>(outOfLineIt);
130  inlineIt += getMaxInlineResults();
131  return reinterpret_cast<Operation *>(const_cast<InlineOpResult *>(inlineIt));
132 }
133 
135  if (offset == 0)
136  return this;
137  // We need to do some arithmetic to get the next result given that results are
138  // in reverse order, and that we need to account for the different types of
139  // results. As a reminder, the rough diagram of the memory layout is:
140  //
141  // | Out-of-Line results | Inline results | Operation |
142  //
143  // So an example operation with two results would look something like:
144  //
145  // | Inline result 1 | Inline result 0 | Operation |
146  //
147 
148  // Handle the case where this result is an inline result.
149  OpResultImpl *result = this;
150  if (auto *inlineResult = dyn_cast<InlineOpResult>(this)) {
151  // Check to see how many results there are after this one before the start
152  // of the out-of-line results. If the desired offset is less than the number
153  // remaining, we can directly use the offset from the current result
154  // pointer. The following diagrams highlight the two situations.
155  //
156  // | Out-of-Line results | Inline results | Operation |
157  // ^- Say we are here.
158  // ^- If our destination is here, we can use the
159  // offset directly.
160  //
161  intptr_t leftBeforeTrailing =
162  getMaxInlineResults() - inlineResult->getResultNumber() - 1;
163  if (leftBeforeTrailing >= offset)
164  return inlineResult - offset;
165 
166  // Otherwise, adjust the current result pointer to the end (start in memory)
167  // of the inline result array.
168  //
169  // | Out-of-Line results | Inline results | Operation |
170  // ^- Say we are here.
171  // ^- If our destination is here, we need to first jump to
172  // the end (start in memory) of the inline result array.
173  //
174  result = inlineResult - leftBeforeTrailing;
175  offset -= leftBeforeTrailing;
176  }
177 
178  // If we land here, the current result is an out-of-line result and we can
179  // offset directly.
180  return reinterpret_cast<OutOfLineOpResult *>(result) - offset;
181 }
182 
183 /// Given a number of operation results, returns the number that need to be
184 /// stored inline.
185 unsigned OpResult::getNumInline(unsigned numResults) {
186  return std::min(numResults, OpResultImpl::getMaxInlineResults());
187 }
188 
189 /// Given a number of operation results, returns the number that need to be
190 /// stored as trailing.
191 unsigned OpResult::getNumTrailing(unsigned numResults) {
192  // If we can pack all of the results, there is no need for additional storage.
193  unsigned maxInline = OpResultImpl::getMaxInlineResults();
194  return numResults <= maxInline ? 0 : numResults - maxInline;
195 }
196 
197 //===----------------------------------------------------------------------===//
198 // BlockOperand
199 //===----------------------------------------------------------------------===//
200 
201 /// Provide the use list that is attached to the given block.
203  return value;
204 }
205 
206 /// Return which operand this is in the operand list.
208  return this - &getOwner()->getBlockOperands()[0];
209 }
210 
211 //===----------------------------------------------------------------------===//
212 // OpOperand
213 //===----------------------------------------------------------------------===//
214 
215 /// Return which operand this is in the operand list.
217  return this - &getOwner()->getOpOperands()[0];
218 }
static Value min(ImplicitLocOpBuilder &builder, Value value, Value bound)
unsigned getOperandNumber()
Return which operand this is in the BlockOperand list of the Operation.
Definition: Value.cpp:207
static IRObjectWithUseList< BlockOperand > * getUseList(Block *value)
Provide the use list that is attached to the given block.
Definition: Value.cpp:202
Block represents an ordered list of Operations.
Definition: Block.h:31
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:63
This class represents an operand of an operation.
Definition: Value.h:267
unsigned getOperandNumber()
Return which operand this is in the OpOperand list of the Operation.
Definition: Value.cpp:216
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
void setLoc(Location loc)
Set the source location the operation was defined or derived from.
Definition: Operation.h:226
Location getLoc()
The source location the operation was defined or derived from.
Definition: Operation.h:223
Block * getBlock()
Returns the operation block that contains this operation.
Definition: Operation.h:213
Region * getParentRegion()
Returns the region to which the instruction belongs.
Definition: Operation.h:230
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
void setLoc(Location loc)
Definition: Value.cpp:33
void replaceUsesWithIf(Value newValue, function_ref< bool(OpOperand &)> shouldReplace)
Replace all uses of 'this' value with 'newValue' if the given callback returns true.
Definition: Value.cpp:81
void shuffleUseList(ArrayRef< unsigned > indices)
Shuffle the use list order according to the provided indices.
Definition: Value.cpp:96
Block * getParentBlock()
Return the Block in which this Value is defined.
Definition: Value.cpp:48
void replaceAllUsesExcept(Value newValue, const SmallPtrSetImpl< Operation * > &exceptions)
Replace all uses of 'this' value with 'newValue', updating anything in the IR that uses 'this' to use...
Definition: Value.cpp:61
bool isUsedOutsideOfBlock(Block *block) const
Returns true if the value is used outside of the given block.
Definition: Value.cpp:89
Location getLoc() const
Return the location of this value.
Definition: Value.cpp:26
Operation * getDefiningOp() const
If this value is the result of an operation, return the operation that defines it.
Definition: Value.cpp:20
Region * getParentRegion()
Return the Region in which this Value is defined.
Definition: Value.cpp:41
This class provides the implementation for an operation result.
Definition: Value.h:368
OpResultImpl * getNextResultAtOffset(intptr_t offset)
Returns the next operation result at offset after this result.
Definition: Value.cpp:134
Operation * getOwner() const
Returns the parent operation of this result.
Definition: Value.cpp:105
static unsigned getMaxInlineResults()
Returns the maximum number of results that can be stored inline.
Definition: Value.h:390
This class provides the implementation for an operation result whose index cannot be represented "inl...
Definition: Value.h:414
uint64_t outOfLineIndex
The trailing result number, or the offset from the beginning of the OutOfLineOpResult array.
Definition: Value.h:431
AttrTypeReplacer.
Include the generated interface declarations.
This class provides the implementation for an operation result whose index can be represented "inline...
Definition: Value.h:397