[mlir] Fixed GCC compile issues and linking problems using SHARED_LIBS.

[dfki-mako]

Summary

This PR fixes several build issues using GCC and shared libraries that have been introduced by the most recent BufferPlacement updates.

[dfki-mako]

Added an additional comment and change to code to use the implicit OperandRange conversion operator.

[pifon2a]

Accepted, but after
OperandRange range = successorOperand;

Value sourceValue = range[0];

is rewritten.

mlir/lib/Transforms/BufferPlacement.cpp

335

i bet this can be written simpler without converting to OperandRange.

[dfki-mako]

mlir/lib/Transforms/BufferPlacement.cpp

335

As discussed offline, a possible alternative would be OperandRange{successorOperand}.begin.

[dfki-mako]

Refactored access to getSuccessorOperands to distinguish between read-only and write-enabled accesses.

mlir/lib/Transforms/BufferPlacement.cpp

auto findUnsafeValues = [&](Value source, Block *definingBlock) {
       for (Value value : it->second) {
         auto blockArg = value.cast<BlockArgument>();
         if (blockArgsToFree.count(blockArg) > 0)
           continue;
         // Check whether we have to free this particular block argument.
         if (!dominators.dominates(definingBlock, blockArg.getOwner())) {
           toProcess.emplace_back(blockArg, blockArg.getParentBlock());
           blockArgsToFree.insert(blockArg);
-        } else if (visitedBlockArgs.insert({blockArg, definingBlock}).second)
+        } else if (visitedBlockArgs
+                       .insert(std::make_tuple(blockArg, definingBlock))
+                       .second)
           toProcess.emplace_back(blockArg, definingBlock);
       }
     };
 
     // Detect possibly unsafe aliases starting from all allocations.
     for (auto &entry : allocs)
       findUnsafeValues(entry.allocValue, entry.placementBlock);
 
for (BlockArgument blockArg : blockArgsToFree) {
       // Allocate a buffer for the current block argument in the block of
       // the associated value (which will be a predecessor block by
       // definition).
       for (auto it = block->pred_begin(), e = block->pred_end(); it != e;
            ++it) {
         // Get the terminator and the value that will be passed to our
         // argument.
         Operation *terminator = (*it)->getTerminator();
-        auto successorOperand =
-            cast<BranchOpInterface>(terminator)
-                .getMutableSuccessorOperands(it.getSuccessorIndex())
-                .getValue()
-                .slice(blockArg.getArgNumber(), 1);
-        Value sourceValue = ((OperandRange)successorOperand)[0];
-
+        auto branchInterface = cast<BranchOpInterface>(terminator);
+        // Convert the mutable operand range to an immutable range and query the
+        // associated source value.
+        Value sourceValue =
+            branchInterface.getSuccessorOperands(it.getSuccessorIndex())
+                .getValue()[blockArg.getArgNumber()];
         // Create a new alloc at the current location of the terminator.
         auto memRefType = sourceValue.getType().cast<MemRefType>();
         OpBuilder builder(terminator);
 
         // Extract information about dynamically shaped types by
         // extracting their dynamic dimensions.
         SmallVector<Value, 4> dynamicOperands;
         for (auto shapeElement : llvm::enumerate(memRefType.getShape())) {
           if (!ShapedType::isDynamic(shapeElement.value()))
             continue;
           dynamicOperands.push_back(builder.create<DimOp>(
               terminator->getLoc(), sourceValue, shapeElement.index()));
         }
 
         // TODO: provide a generic interface to create dialect-specific
         // Alloc and CopyOp nodes.
         auto alloc = builder.create<AllocOp>(terminator->getLoc(), memRefType,
                                              dynamicOperands);
         // Wire new alloc and successor operand.
-        successorOperand.assign(alloc);
+        branchInterface.getMutableSuccessorOperands(it.getSuccessorIndex())
+            .getValue()
+            .slice(blockArg.getArgNumber(), 1)
+            .assign(alloc);
         // Create a new copy operation that copies to contents of the old
         // allocation to the new one.
         builder.create<linalg::CopyOp>(terminator->getLoc(), sourceValue,
                                        alloc);
       }
 
       // Register the block argument to require a final dealloc. Note that
       // we do not have to assign a block here since we do not want to

mlir/lib/Transforms/CMakeLists.txt

add_mlir_library(MLIRTransforms
 
   DEPENDS
   MLIRStandardOpsIncGen
   MLIRTransformsPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRAffineOps
   MLIRAnalysis
+  MLIRLinalgOps
   MLIRLoopLikeInterface
   MLIRSCF
   MLIRPass
   MLIRTransformUtils
   MLIRVector
   )