[MLIR] Change FuncOp assembly syntax to print visibility inline instead of in attrib dict.

[jurahul]

Summary

• Change syntax for FuncOp to be func "<visibility>" @name instead of printing the visibility in the attribute dictionary.
• Since printFunctionLikeOp() and parseFunctionLikeOp() are also used by other operations, make the "inline visibility" an opt-in feature.
• Updated unit test to use and check the new syntax.

[ftynse]

As a syntactic nit, we don't have to print an attribute as a quoted string. It can be printed and parsed as a keyword with parseOptionalKeyword(StringRef *), from which one then creates an attribute of any desired type using a StringSwitch. This would give func private @private_function instead, which I personally prefer. As a historic reference, I introduced the first operation with "attribute" in its syntax -- cmpi -- which I now regret because many other operations follows suit.

[jurahul]

I don't think there's a way to do that with the declarative parses though, and we use that std.global_memref so I avoided diverging the syntax between the two. But I do agree that quotes are not that readable. I can change this to be unquoted, but then we would need to change global_memref to use the similar syntax, likely by using the custom directive. @rriddle/@mehdi_amin, what do you think? It almost seems that the SymbolTable can provide helper functions to print/parse visibility that can be reused here across ops.

[jurahul]

Update syntax to not have quotes around visibility

[rriddle]

We could move the visibility enum to ODS, which would automatically give the correct formatting when the attribute is used on symbol operations.

mlir/include/mlir/IR/FunctionImplementation.h

81

Is this solely a staging thing? We should just always do this.

mlir/include/mlir/IR/OpImplementation.h

146

Please do not do this, just unwrap the StringAttr at the callsite.

357

This doesn't look like it needs to be a virtual method.

511

Please do not put this on the OpAsmParser, it is completely unrelated.

[jurahul]

mlir/include/mlir/IR/FunctionImplementation.h

81

Yes, it's a staging think at least. There are other operations that use this functionality and I am not changing all of them. I can do this for other in-tree ones in later CL's, but need to work with other folks for out-of-tree ones. May be this is something we can make default in a few weeks after all known users have been migrated to the new syntax and we give advanced notice on discourse.

mlir/include/mlir/IR/OpImplementation.h

146

Will do.

357

Agreed. Will change.

511

The other place I can think of is SymbolTable static method. Would that work? I anticipate other op's could use it when we migrate to the new syntax.

[jurahul]

I did think of moving the visibility enums to ODS, but I wasn't sure how operations like ModuleOp and FuncOp that are defined outside ODS will use it. Also StrEnumAttr still prints a quoted string I think, so beyond that, we would also need some kind of qualifier in the declarative assembly syntax to indicate that the custom parser needs to print it without quotes (something like noquotes($sym_visibility)). So did not go down that path.

[rriddle]

mlir/include/mlir/IR/OpImplementation.h

511

The main MLIR ideology is to keep these types of very open/very common interface points as clean as possible. Putting these in SymbolTable.h is probably fine (though ideally most users should try to use the declarative syntax). I wouldn't put them in the SymbolTable class though, we can put them in an impl namespace like these methods: https://github.com/llvm/llvm-project/blob/1ca7f055ad81346bae6fc6f8b35de306b4afe169/mlir/include/mlir/IR/OpDefinition.h#L1631

[jurahul]

mlir/include/mlir/IR/OpImplementation.h

357

Actually, I take that back. We can make it non-virtual by calling one of the parseOptionalKeyword variants per allowed keyword, but that's several virtual function calls with redundant check between then (like is current token a isCurrentTokenAKeyword). With a virtual, all this overhead can be avoided.

[jurahul]

Review feedback

[jurahul]

mlir/include/mlir/IR/FunctionImplementation.h

81

Commented on this earlier.

mlir/include/mlir/IR/OpImplementation.h

511

Moved it to SymbolTable.h with impl in SymbolTable.cpp.

[jurahul]

Use llvm::is_contained() in parseOptionalKeyword

[rriddle]

We should update OpFormatGen(I can do this) to support formatting enums with a keyword instead of a StringAttr when it is possible, but this is fine for now. Thanks for cleaning this up!

mlir/include/mlir/IR/FunctionImplementation.h

81

Thanks, just want to make sure this gets followed up on.

mlir/include/mlir/IR/OpImplementation.h

357

SGTM

mlir/include/mlir/IR/SymbolTable.h

314

There is only ever one possible attribute name for this, do we need to specify this?

[ftynse]

In D90859#2381710, @rriddle wrote:

We should update OpFormatGen(I can do this) to support formatting enums with a keyword instead of a StringAttr when it is possible, but this is fine for now. Thanks for cleaning this up!

This would be great, thanks!

[jurahul]

Address feedback

mlir/docs/SymbolsAndSymbolTables.md

*   Private
     -   The symbol may only be referenced from within the current symbol table.
 
 *   Nested
 
     -   The symbol may be referenced by operations outside of the current symbol
         table, but not outside of the visible IR, as long as each symbol table
         parent also defines a non-private symbol.
 
-A few examples of what this looks like in the IR are shown below:
+For Functions, the visibility is printed after the operation name without a
+quote. A few examples of what this looks like in the IR are shown below:
 
 ```mlir
 module @public_module {
   // This function can be accessed by 'live.user', but cannot be referenced
   // externally; all uses are known to reside within parent regions.
-  func @nested_function() attributes { sym_visibility = "nested" }
+  func nested @nested_function()
 
   // This function cannot be accessed outside of 'public_module'.
-  func @private_function() attributes { sym_visibility = "private" }
+  func private @private_function()
 }
 
 // This function can only be accessed from within the top-level module.
-func @private_function() attributes { sym_visibility = "private" }
+func private @private_function()
 
 // This function may be referenced externally.
 func @public_function()
 
 "live.user"() {uses = [
   @public_module::@nested_function,
   @private_function,
   @public_function
 ]} : () -> ()
 ```

mlir/include/mlir/IR/FunctionImplementation.h

 
 /// Parser implementation for function-like operations.  Uses
 /// `funcTypeBuilder` to construct the custom function type given lists of
 /// input and output types.  If `allowVariadic` is set, the parser will accept
 /// trailing ellipsis in the function signature and indicate to the builder
 /// whether the function is variadic.  If the builder returns a null type,
 /// `result` will not contain the `type` attribute.  The caller can then add a
 /// type, report the error or delegate the reporting to the op's verifier.
+/// If `allowInlineVisibility` is true, then the parser will allow visibility
+/// to be specified after the operation name. If the visibility is not specified
+/// there or `allowInlineVisibility` is false, visibility will be allowed in the
+/// attribute dict.
 ParseResult parseFunctionLikeOp(OpAsmParser &parser, OperationState &result,
                                 bool allowVariadic,
-                                FuncTypeBuilder funcTypeBuilder);
+                                FuncTypeBuilder funcTypeBuilder,
+                                bool allowInlineVisibility = false);
 
 /// Printer implementation for function-like operations.  Accepts lists of
-/// argument and result types to use while printing.
+/// argument and result types to use while printing. If `printVisibilityInline`
+/// is true, visibility is printed "inline" after the operation name and elided
+/// from the attributes dict. Otherwise, it is printed in the attribute dict.
 void printFunctionLikeOp(OpAsmPrinter &p, Operation *op,
                          ArrayRef<Type> argTypes, bool isVariadic,
-                         ArrayRef<Type> resultTypes);
+                         ArrayRef<Type> resultTypes,
+                         bool printVisibilityInline = false);
 
 /// Prints the signature of the function-like operation `op`.  Assumes `op` has
 /// the FunctionLike trait and passed the verification.
 void printFunctionSignature(OpAsmPrinter &p, Operation *op,
                             ArrayRef<Type> argTypes, bool isVariadic,
                             ArrayRef<Type> resultTypes);
 
 /// Prints the list of function prefixed with the "attributes" keyword. The

mlir/include/mlir/IR/OpImplementation.h

public:
 
   /// Print the given string as a symbol reference, i.e. a form representable by
   /// a SymbolRefAttr. A symbol reference is represented as a string prefixed
   /// with '@'. The reference is surrounded with ""'s and escaped if it has any
   /// special or non-printable characters in it.
   virtual void printSymbolName(StringRef symbolRef) = 0;
 
 private:
   OpAsmPrinter(const OpAsmPrinter &) = delete;
   void operator=(const OpAsmPrinter &) = delete;
 };
 
 // Make the implementations convenient to use.
 inline OpAsmPrinter &operator<<(OpAsmPrinter &p, Value value) {
   p.printOperand(value);
   return p;
 }
public:
   }
 
   /// Parse the given keyword if present.
   virtual ParseResult parseOptionalKeyword(StringRef keyword) = 0;
 
   /// Parse a keyword, if present, into 'keyword'.
   virtual ParseResult parseOptionalKeyword(StringRef *keyword) = 0;
 
+  /// Parse a keyword, if present, and if one of the 'allowedValues',
+  /// into 'keyword'
+  virtual ParseResult
+  parseOptionalKeyword(StringRef *keyword,
+                       ArrayRef<StringRef> allowedValues) = 0;
+
   /// Parse a `(` token.
   virtual ParseResult parseLParen() = 0;
 
   /// Parse a `(` token if present.
   virtual ParseResult parseOptionalLParen() = 0;
 
   /// Parse a `)` token.
   virtual ParseResult parseRParen() = 0;
virtual ParseResult parseOptionalSymbolName(StringAttr &result,
                                               StringRef attrName,
                                               NamedAttrList &attrs) = 0;
 
   //===--------------------------------------------------------------------===//
   // Operand Parsing
   //===--------------------------------------------------------------------===//
 
   /// This is the representation of an operand reference.
   struct OperandType {
     llvm::SMLoc location; // Location of the token.
     StringRef name;       // Value name, e.g. %42 or %abc
     unsigned number;      // Number, e.g. 12 for an operand like %xyz#12
   };
 
   /// Parse a single operand.
   virtual ParseResult parseOperand(OperandType &result) = 0;
 

mlir/include/mlir/IR/SymbolTable.h

public:
   }
   template <typename T>
   T lookupSymbol(SymbolRefAttr symbol) {
     return dyn_cast_or_null<T>(lookupSymbol(symbol));
   }
 };
 
 } // end namespace OpTrait
+
+//===----------------------------------------------------------------------===//
+// Visibility parsing implementation.
+//===----------------------------------------------------------------------===//
+
+namespace impl {
+/// Parse an optional visibility attribute keyword (i.e., public, private, or
+/// nested) without quotes in a string attribute named 'attrName'.
+ParseResult parseOptionalVisibilityKeyword(OpAsmParser &parser,
+                                           NamedAttrList &attrs);
+} // end namespace impl
+
 } // end namespace mlir
 
 /// Include the generated symbol interfaces.
 #include "mlir/IR/SymbolInterfaces.h.inc"
 
 #endif // MLIR_IR_SYMBOLTABLE_H

mlir/include/mlir/Transforms/Passes.td

let description = [{
     within this live set. Live symbols are those that have a
     [visibility](SymbolsAndSymbolTables.md#symbol-visibility) that extends
     beyond the IR, e.g. `public`, or those that are referenced by live symbols
     or other non-Symbol operations.
 
     For example, consider the following input:
 
     ```mlir
-    func @dead_private_function() attributes { sym_visibility = "private" }
-    func @live_private_function() attributes { sym_visibility = "private" }
+    func private @dead_private_function()
+    func private @live_private_function()
 
     // Note: The `public` isn't necessary here, as this is the default.
-    func @public_function() attributes { sym_visibility = "public" } {
+    func public @public_function() {
       "foo.return"() {uses = [@live_private_function]} : () -> ()
     }
     ```
 
     A known live function, `public_function`, contains a reference to an
     otherwise non-live function `live_private_function`. After running
     `symbol-dce`, only these two symbols should remain, as the final symbol
     `dead_private_function` is not visible outside of the current IR and there
     are no links to known-live operations. After running, we get the expected:
 
     ```mlir
-    func @live_private_function() attributes { sym_visibility = "private" }
+    func private @live_private_function()
 
-    func @public_function() attributes { sym_visibility = "public" } {
+    func public @public_function() {
       "foo.return"() {uses = [@live_private_function]} : () -> ()
     }
     ```
 
     See [Symbols and SymbolTables](SymbolsAndSymbolTables.md) for more
     information on `Symbols`.
   }];
   let constructor = "mlir::createSymbolDCEPass()";
 }
 #endif // MLIR_TRANSFORMS_PASSES

mlir/lib/IR/Function.cpp

 ParseResult FuncOp::parse(OpAsmParser &parser, OperationState &result) {
   auto buildFuncType = [](Builder &builder, ArrayRef<Type> argTypes,
                           ArrayRef<Type> results, impl::VariadicFlag,
                           std::string &) {
     return builder.getFunctionType(argTypes, results);
   };
 
   return impl::parseFunctionLikeOp(parser, result, /*allowVariadic=*/false,
-                                   buildFuncType);
+                                   buildFuncType,
+                                   /*allowInlineVisibility=*/true);
 }
 
 void FuncOp::print(OpAsmPrinter &p) {
   FunctionType fnType = getType();
   impl::printFunctionLikeOp(p, *this, fnType.getInputs(), /*isVariadic=*/false,
-                            fnType.getResults());
+                            fnType.getResults(),
+                            /*printVisibilityInline=*/true);
 }
 
 LogicalResult FuncOp::verify() {
   // If this function is external there is nothing to do.
   if (isExternal())
     return success();
 
   // Verify that the argument list of the function and the arg list of the entry

mlir/lib/IR/FunctionImplementation.cpp

void mlir::impl::addArgAndResultAttrs(Builder &builder, OperationState &result,
   for (unsigned i = 0, e = resultAttrs.size(); i != e; ++i)
     if (!resultAttrs[i].empty())
       result.addAttribute(getResultAttrName(i, attrNameBuf),
                           builder.getDictionaryAttr(resultAttrs[i]));
 }
 
 /// Parser implementation for function-like operations.  Uses `funcTypeBuilder`
 /// to construct the custom function type given lists of input and output types.
-ParseResult
-mlir::impl::parseFunctionLikeOp(OpAsmParser &parser, OperationState &result,
-                                bool allowVariadic,
-                                mlir::impl::FuncTypeBuilder funcTypeBuilder) {
+ParseResult mlir::impl::parseFunctionLikeOp(
+    OpAsmParser &parser, OperationState &result, bool allowVariadic,
+    mlir::impl::FuncTypeBuilder funcTypeBuilder, bool allowInlineVisibility) {
   SmallVector<OpAsmParser::OperandType, 4> entryArgs;
   SmallVector<NamedAttrList, 4> argAttrs;
   SmallVector<NamedAttrList, 4> resultAttrs;
   SmallVector<Type, 4> argTypes;
   SmallVector<Type, 4> resultTypes;
   auto &builder = parser.getBuilder();
 
+  // Parse visibility if inline visibility is allowed.
+  if (allowInlineVisibility)
+    impl::parseOptionalVisibilityKeyword(parser, result.attributes);
+
   // Parse the name as a symbol.
   StringAttr nameAttr;
-  if (parser.parseSymbolName(nameAttr, ::mlir::SymbolTable::getSymbolAttrName(),
+  if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              result.attributes))
     return failure();
 
   // Parse the function signature.
   auto signatureLocation = parser.getCurrentLocation();
   bool isVariadic = false;
   if (parseFunctionSignature(parser, allowVariadic, entryArgs, argTypes,
                              argAttrs, isVariadic, resultTypes, resultAttrs))
void mlir::impl::printFunctionAttributes(OpAsmPrinter &p, Operation *op,
 
   p.printOptionalAttrDictWithKeyword(op->getAttrs(), ignoredAttrs);
 }
 
 /// Printer implementation for function-like operations.  Accepts lists of
 /// argument and result types to use while printing.
 void mlir::impl::printFunctionLikeOp(OpAsmPrinter &p, Operation *op,
                                      ArrayRef<Type> argTypes, bool isVariadic,
-                                     ArrayRef<Type> resultTypes) {
+                                     ArrayRef<Type> resultTypes,
+                                     bool printVisibilityInline) {
   // Print the operation and the function name.
   auto funcName =
-      op->getAttrOfType<StringAttr>(::mlir::SymbolTable::getSymbolAttrName())
+      op->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName())
           .getValue();
   p << op->getName() << ' ';
+  StringRef elidedAttr;
+  if (printVisibilityInline) {
+    elidedAttr = SymbolTable::getVisibilityAttrName();
+    if (auto visibility = op->getAttrOfType<StringAttr>(elidedAttr))
+      p << visibility.getValue() << ' ';
+  }
   p.printSymbolName(funcName);
 
   printFunctionSignature(p, op, argTypes, isVariadic, resultTypes);
-  printFunctionAttributes(p, op, argTypes.size(), resultTypes.size());
-
+  printFunctionAttributes(p, op, argTypes.size(), resultTypes.size(),
+                          {elidedAttr});
   // Print the body if this is not an external function.
   Region &body = op->getRegion(0);
   if (!body.empty())
     p.printRegion(body, /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/true);
 }

mlir/lib/IR/SymbolTable.cpp

 //===- SymbolTable.cpp - MLIR Symbol Table Class --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/OpImplementation.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace mlir;
 
 /// Return true if the given operation is unknown and may potentially define a

 SymbolTable &SymbolTableCollection::getSymbolTable(Operation *op) {
   auto it = symbolTables.try_emplace(op, nullptr);
   if (it.second)
     it.first->second = std::make_unique<SymbolTable>(op);
   return *it.first->second;
 }
 
 //===----------------------------------------------------------------------===//
+// Visibility parsing implementation.
+//===----------------------------------------------------------------------===//
+
+ParseResult impl::parseOptionalVisibilityKeyword(OpAsmParser &parser,
+                                                 NamedAttrList &attrs) {
+  StringRef visibility;
+  if (parser.parseOptionalKeyword(&visibility, {"public", "private", "nested"}))
+    return failure();
+
+  StringAttr visibilityAttr = parser.getBuilder().getStringAttr(visibility);
+  attrs.push_back(parser.getBuilder().getNamedAttr(
+      SymbolTable::getVisibilityAttrName(), visibilityAttr));
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // Symbol Interfaces
 //===----------------------------------------------------------------------===//
 
 /// Include the generated symbol interfaces.
 #include "mlir/IR/SymbolInterfaces.cpp.inc"

mlir/lib/Parser/Parser.cpp

ParseResult parseOptionalKeyword(StringRef *keyword) override {
     if (!isCurrentTokenAKeyword())
       return failure();
 
     *keyword = parser.getTokenSpelling();
     parser.consumeToken();
     return success();
   }
 
+  /// Parse a keyword if it is one of the 'allowedKeywords'.
+  ParseResult
+  parseOptionalKeyword(StringRef *keyword,
+                       ArrayRef<StringRef> allowedKeywords) override {
+    // Check that the current token is a keyword.
+    if (!isCurrentTokenAKeyword())
+      return failure();
+
+    StringRef currentKeyword = parser.getTokenSpelling();
+    if (llvm::is_contained(allowedKeywords, currentKeyword)) {
+      *keyword = currentKeyword;
+      parser.consumeToken();
+      return success();
+    }
+
+    return failure();
+  }
+
   /// Parse an optional @-identifier and store it (without the '@' symbol) in a
   /// string attribute named 'attrName'.
   ParseResult parseOptionalSymbolName(StringAttr &result, StringRef attrName,
                                       NamedAttrList &attrs) override {
     Token atToken = parser.getToken();
     if (atToken.isNot(Token::at_identifier))
       return failure();
 

mlir/test/Conversion/AsyncToLLVM/convert-to-llvm.mlir

func @execute_no_async_args(%arg0: f32, %arg1: memref<1xf32>) {
   }
   // CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]])
   // CHECK-NEXT: return
   async.await %token : !async.token
   return
 }
 
 // Function outlined from the async.execute operation.
-// CHECK-LABEL: func @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
-// CHECK-SAME: -> !llvm.ptr<i8> attributes {sym_visibility = "private"}
+// CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
+// CHECK-SAME: -> !llvm.ptr<i8>
 
 // Create token for return op, and mark a function as a coroutine.
 // CHECK: %[[RET:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
 
 // Pass a suspended coroutine to the async runtime.
 // CHECK: %[[RESUME:.*]] = llvm.mlir.addressof @__resume
 // CHECK: %[[STATE:.*]] = llvm.call @llvm.coro.save
func @nested_async_execute(%arg0: f32, %arg1: f32, %arg2: memref<1xf32>) {
   }
   // CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]])
   // CHECK-NEXT: return
   async.await %token0 : !async.token
   return
 }
 
 // Function outlined from the inner async.execute operation.
-// CHECK-LABEL: func @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>, %arg2: index)
-// CHECK-SAME: -> !llvm.ptr<i8> attributes {sym_visibility = "private"}
+// CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>, %arg2: index)
+// CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_0:.*]] = llvm.call @llvm.coro.begin
 // CHECK: call @mlirAsyncRuntimeExecute
 // CHECK: llvm.call @llvm.coro.suspend
 // CHECK: store %arg0, %arg1[%arg2] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_0]])
 
 // Function outlined from the outer async.execute operation.
-// CHECK-LABEL: func @async_execute_fn_0(%arg0: f32, %arg1: memref<1xf32>, %arg2: f32)
-// CHECK-SAME: -> !llvm.ptr<i8> attributes {sym_visibility = "private"}
+// CHECK-LABEL: func private @async_execute_fn_0(%arg0: f32, %arg1: memref<1xf32>, %arg2: f32)
+// CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_1:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_1:.*]] = llvm.call @llvm.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute
 // CHECK: llvm.call @llvm.coro.suspend
 
 // Suspend coroutine second time waiting for the completion of inner execute op.
%token_0 = async.execute [%token] {
     %c0 = constant 0 : index
     store %arg0, %arg1[%c0] : memref<1xf32>
     async.yield
   }
   return
 }
 
 // Function outlined from the first async.execute operation.
-// CHECK-LABEL: func @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
-// CHECK-SAME: -> !llvm.ptr<i8> attributes {sym_visibility = "private"}
+// CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
+// CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_0:.*]] = llvm.call @llvm.coro.begin
 // CHECK: call @mlirAsyncRuntimeExecute
 // CHECK: llvm.call @llvm.coro.suspend
 // CHECK: store %arg0, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_0]])
 
 // Function outlined from the second async.execute operation with dependency.
-// CHECK-LABEL: func @async_execute_fn_0(%arg0: !llvm.ptr<i8>, %arg1: f32, %arg2: memref<1xf32>)
-// CHECK-SAME: -> !llvm.ptr<i8> attributes {sym_visibility = "private"}
+// CHECK-LABEL: func private @async_execute_fn_0(%arg0: !llvm.ptr<i8>, %arg1: f32, %arg2: memref<1xf32>)
+// CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_1:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_1:.*]] = llvm.call @llvm.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL_1]],
 // CHECK: llvm.call @llvm.coro.suspend
 
 // Suspend coroutine second time waiting for the completion of token dependency.

mlir/test/Examples/Toy/Ch4/codegen.toy

 # RUN: toyc-ch4 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func @multiply_transpose(
+# CHECK-LABEL: func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
 # CHECK-LABEL: func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch4/shape_inference.mlir

 // RUN: toyc-ch4 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
-    attributes { sym_visibility = "private" } {
+func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
 func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>
   %2 = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
   %3 = toy.reshape(%2 : tensor<6xf64>) to tensor<2x3xf64>
   %4 = toy.generic_call @multiply_transpose(%1, %3) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   %5 = toy.generic_call @multiply_transpose(%3, %1) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   toy.print %5 : tensor<*xf64>
   toy.return
 }
 
-// CHECK-NOT: func @multiply_transpose
+// CHECK-NOT: func private @multiply_transpose
 // CHECK-NOT: tensor<*xf64>
 
 // CHECK-LABEL: func @main()
 // CHECK:         [[VAL_0:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 // CHECK:         [[VAL_1:%.*]] = toy.transpose([[VAL_0]] : tensor<2x3xf64>) to tensor<3x2xf64>
 // CHECK:         [[VAL_2:%.*]] = toy.mul [[VAL_1]], [[VAL_1]] : tensor<3x2xf64>
 // CHECK:         toy.print [[VAL_2]] : tensor<3x2xf64>
 // CHECK:         toy.return

mlir/test/Examples/Toy/Ch5/codegen.toy

 # RUN: toyc-ch5 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func @multiply_transpose(
+# CHECK-LABEL: func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
 # CHECK-LABEL: func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch5/shape_inference.mlir

 // RUN: toyc-ch5 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
-    attributes { sym_visibility = "private" } {
+func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
 func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>

mlir/test/Examples/Toy/Ch6/codegen.toy

 # RUN: toyc-ch6 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func @multiply_transpose(
+# CHECK-LABEL: func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
 # CHECK-LABEL: func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch6/shape_inference.mlir

 // RUN: toyc-ch6 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
-    attributes { sym_visibility = "private" } {
+func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
 func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>

mlir/test/Examples/Toy/Ch7/codegen.toy

 # RUN: toyc-ch7 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func @multiply_transpose(
+# CHECK-LABEL: func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
 # CHECK-LABEL: func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch7/shape_inference.mlir

 // RUN: toyc-ch7 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
-    attributes { sym_visibility = "private" } {
+func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
 func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>

mlir/test/Examples/Toy/Ch7/struct-codegen.toy

def main() {
   # We initialize struct values using a composite initializer.
   Struct value = {[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]};
 
   # We pass these arguments to functions like we do with variables.
   var c = multiply_transpose(value);
   print(c);
 }
 
-# CHECK-LABEL:   func @multiply_transpose(
+# CHECK-LABEL:   func private @multiply_transpose(
 # CHECK-SAME:                             [[VAL_0:%.*]]: !toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64>
-# CHECK-SAME:        attributes {sym_visibility = "private"}
 # CHECK-NEXT:      [[VAL_1:%.*]] = toy.struct_access [[VAL_0]][0] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_2:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:      [[VAL_3:%.*]] = toy.struct_access [[VAL_0]][1] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_4:%.*]] = toy.transpose([[VAL_3]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:      [[VAL_5:%.*]] = toy.mul [[VAL_2]], [[VAL_4]] : tensor<*xf64>
 # CHECK-NEXT:      toy.return [[VAL_5]] : tensor<*xf64>
 
 # CHECK-LABEL:   func @main()

mlir/test/IR/core-ops.mlir

func @subtensor_insert(%t: tensor<8x16x4xf32>, %t2: tensor<16x32x8xf32>, %idx : index) {
 
   // CHECK: subtensor_insert
   // CHECK-SAME: tensor<8x16x4xf32> into tensor<16x32x8xf32>
   %2 = subtensor_insert %t into %t2[%c0, %idx, %c0][%idx, 4, %idx][%c1, 1, %c1]
     : tensor<8x16x4xf32> into tensor<16x32x8xf32>
 
   return
 }
+
+// CHECK-LABEL: func private @legacy_visibility_syntax
+func @legacy_visibility_syntax() attributes { sym_visibility = "private" }
+

mlir/test/Transforms/inlining-dce.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -inline -split-input-file | FileCheck %s
 
 // This file tests the callgraph dead code elimination performed by the inliner.
 
 // Function is already dead.
-// CHECK-NOT: func @dead_function
-func @dead_function() attributes {sym_visibility = "private"} {
+// CHECK-NOT: func private @dead_function
+func private @dead_function() {
   return
 }
 
 // Function becomes dead after inlining.
-// CHECK-NOT: func @dead_function_b
-func @dead_function_b() attributes {sym_visibility = "private"} {
+// CHECK-NOT: func private @dead_function_b
+func @dead_function_b() {
   return
 }
 
 // CHECK: func @live_function()
 func @live_function() {
   call @dead_function_b() : () -> ()
   return
 }
 
 // Same as above, but a transitive example.
 
 // CHECK: func @live_function_b
 func @live_function_b() {
   return
 }
-// CHECK-NOT: func @dead_function_c
-func @dead_function_c() attributes {sym_visibility = "private"} {
+// CHECK-NOT: func private @dead_function_c
+func private @dead_function_c() {
   call @live_function_b() : () -> ()
   return
 }
-// CHECK-NOT: func @dead_function_d
-func @dead_function_d() attributes {sym_visibility = "private"} {
+// CHECK-NOT: func private @dead_function_d
+func private @dead_function_d() {
   call @dead_function_c() : () -> ()
   call @dead_function_c() : () -> ()
   return
 }
 // CHECK: func @live_function_c
 func @live_function_c() {
   call @dead_function_c() : () -> ()
   call @dead_function_d() : () -> ()
   return
 }
 
 // Function is referenced by non-callable top-level user.
-// CHECK: func @live_function_d
-func @live_function_d() attributes {sym_visibility = "private"} {
+// CHECK: func private @live_function_d
+func private @live_function_d() {
   return
 }
 
 "live.user"() {use = @live_function_d} : () -> ()
 
 // -----
 
 // This test checks that the inliner can properly handle the deletion of
 // functions in different SCCs that are referenced by calls materialized during
 // canonicalization.
 // CHECK: func @live_function_e
 func @live_function_e() {
   call @dead_function_e() : () -> ()
   return
 }
 // CHECK-NOT: func @dead_function_e
-func @dead_function_e() -> () attributes {sym_visibility = "private"} {
+func private @dead_function_e() -> () {
   "test.fold_to_call_op"() {callee=@dead_function_f} : () -> ()
   return
 }
-// CHECK-NOT: func @dead_function_f
-func @dead_function_f() attributes {sym_visibility = "private"} {
+// CHECK-NOT: func private @dead_function_f
+func private @dead_function_f() {
   return
 }

mlir/test/Transforms/sccp-callgraph.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -sccp -split-input-file | FileCheck %s
 // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="module(sccp)" -split-input-file | FileCheck %s --check-prefix=NESTED
 
 /// Check that a constant is properly propagated through the arguments and
 /// results of a private function.
 
-// CHECK-LABEL: func @private(
-func @private(%arg0 : i32) -> i32 attributes { sym_visibility = "private" } {
+// CHECK-LABEL: func private @private(
+func private @private(%arg0 : i32) -> i32 {
   // CHECK: %[[CST:.*]] = constant 1 : i32
   // CHECK: return %[[CST]] : i32
 
   return %arg0 : i32
 }
 
 // CHECK-LABEL: func @simple_private(
 func @simple_private() -> i32 {
   // CHECK: %[[CST:.*]] = constant 1 : i32
   // CHECK: return %[[CST]] : i32
 
   %1 = constant 1 : i32
   %result = call @private(%1) : (i32) -> i32
   return %result : i32
 }
 
 // -----
 
 /// Check that a constant is properly propagated through the arguments and
 /// results of a visible nested function.
 
-// CHECK: func @nested(
-func @nested(%arg0 : i32) -> i32 attributes { sym_visibility = "nested" } {
+// CHECK: func nested @nested(
+func nested @nested(%arg0 : i32) -> i32 {
   // CHECK: %[[CST:.*]] = constant 1 : i32
   // CHECK: return %[[CST]] : i32
 
   return %arg0 : i32
 }
 
 // CHECK-LABEL: func @simple_nested(
 func @simple_nested() -> i32 {
   // CHECK: %[[CST:.*]] = constant 1 : i32
   // CHECK: return %[[CST]] : i32
 
   %1 = constant 1 : i32
   %result = call @nested(%1) : (i32) -> i32
   return %result : i32
 }
 
 // -----
 
 /// Check that non-visible nested functions do not track arguments.
 module {
   // NESTED-LABEL: module @nested_module
   module @nested_module attributes { sym_visibility = "public" } {
 
-    // NESTED: func @nested(
-    func @nested(%arg0 : i32) -> (i32, i32) attributes { sym_visibility = "nested" } {
+    // NESTED: func nested @nested(
+    func nested @nested(%arg0 : i32) -> (i32, i32) {
       // NESTED: %[[CST:.*]] = constant 1 : i32
       // NESTED: return %[[CST]], %arg0 : i32, i32
 
       %1 = constant 1 : i32
       return %1, %arg0 : i32, i32
     }
 
     // NESTED: func @nested_not_all_uses_visible(
module {
   }
 }
 
 // -----
 
 /// Check that public functions do not track arguments.
 
 // CHECK-LABEL: func @public(
-func @public(%arg0 : i32) -> (i32, i32) attributes { sym_visibility = "public" } {
+func @public(%arg0 : i32) -> (i32, i32) {
   %1 = constant 1 : i32
   return %1, %arg0 : i32, i32
 }
 
 // CHECK-LABEL: func @simple_public(
 func @simple_public() -> (i32, i32) {
   // CHECK: %[[CST:.*]] = constant 1 : i32
   // CHECK: %[[CALL:.*]]:2 = call @public
   // CHECK: return %[[CST]], %[[CALL]]#1 : i32, i32
 
   %1 = constant 1 : i32
   %result:2 = call @public(%1) : (i32) -> (i32, i32)
   return %result#0, %result#1 : i32, i32
 }
 
 // -----
 
 /// Check that functions with non-call users don't have arguments tracked.
 
-func @callable(%arg0 : i32) -> (i32, i32) attributes { sym_visibility = "private" } {
+func private @callable(%arg0 : i32) -> (i32, i32) {
   %1 = constant 1 : i32
   return %1, %arg0 : i32, i32
 }
 
 // CHECK-LABEL: func @non_call_users(
 func @non_call_users() -> (i32, i32) {
   // CHECK: %[[CST:.*]] = constant 1 : i32
   // CHECK: %[[CALL:.*]]:2 = call @callable
   // CHECK: return %[[CST]], %[[CALL]]#1 : i32, i32
 
   %1 = constant 1 : i32
   %result:2 = call @callable(%1) : (i32) -> (i32, i32)
   return %result#0, %result#1 : i32, i32
 }
 
 "live.user"() {uses = [@callable]} : () -> ()
 
 // -----
 
 /// Check that return values are overdefined in the presence of an unknown terminator.
 
-func @callable(%arg0 : i32) -> i32 attributes { sym_visibility = "private" } {
+func private @callable(%arg0 : i32) -> i32 {
   "unknown.return"(%arg0) : (i32) -> ()
 }
 
 // CHECK-LABEL: func @unknown_terminator(
 func @unknown_terminator() -> i32 {
   // CHECK: %[[CALL:.*]] = call @callable
   // CHECK: return %[[CALL]] : i32
 
   %1 = constant 1 : i32
   %result = call @callable(%1) : (i32) -> i32
   return %result : i32
 }
 
 // -----
 
 /// Check that return values are overdefined when the constant conflicts.
 
-func @callable(%arg0 : i32) -> i32 attributes { sym_visibility = "private" } {
+func private @callable(%arg0 : i32) -> i32 {
   "unknown.return"(%arg0) : (i32) -> ()
 }
 
 // CHECK-LABEL: func @conflicting_constant(
 func @conflicting_constant() -> (i32, i32) {
   // CHECK: %[[CALL1:.*]] = call @callable
   // CHECK: %[[CALL2:.*]] = call @callable
   // CHECK: return %[[CALL1]], %[[CALL2]] : i32, i32
 
   %1 = constant 1 : i32
   %2 = constant 2 : i32
   %result = call @callable(%1) : (i32) -> i32
   %result2 = call @callable(%2) : (i32) -> i32
   return %result, %result2 : i32, i32
 }
 
 // -----
 
 /// Check that return values are overdefined when the constant conflicts with a
 /// non-constant.
 
-func @callable(%arg0 : i32) -> i32 attributes { sym_visibility = "private" } {
+func private @callable(%arg0 : i32) -> i32 {
   "unknown.return"(%arg0) : (i32) -> ()
 }
 
 // CHECK-LABEL: func @conflicting_constant(
 func @conflicting_constant(%arg0 : i32) -> (i32, i32) {
   // CHECK: %[[CALL1:.*]] = call @callable
   // CHECK: %[[CALL2:.*]] = call @callable
   // CHECK: return %[[CALL1]], %[[CALL2]] : i32, i32
 
   %1 = constant 1 : i32
   %result = call @callable(%1) : (i32) -> i32
   %result2 = call @callable(%arg0) : (i32) -> i32
   return %result, %result2 : i32, i32
 }
 
 // -----
 
 /// Check a more complex interaction with calls and control flow.
 
-// CHECK-LABEL: func @complex_inner_if(
-func @complex_inner_if(%arg0 : i32) -> i32 attributes { sym_visibility = "private" } {
+// CHECK-LABEL: func private @complex_inner_if(
+func private @complex_inner_if(%arg0 : i32) -> i32 {
   // CHECK-DAG: %[[TRUE:.*]] = constant true
   // CHECK-DAG: %[[CST:.*]] = constant 1 : i32
   // CHECK: cond_br %[[TRUE]], ^bb1
 
   %cst_20 = constant 20 : i32
   %cond = cmpi "ult", %arg0, %cst_20 : i32
   cond_br %cond, ^bb1, ^bb2
 
 ^bb1:
   // CHECK: ^bb1:
   // CHECK: return %[[CST]] : i32
 
   %cst_1 = constant 1 : i32
   return %cst_1 : i32
 
 ^bb2:
   %cst_1_2 = constant 1 : i32
   %arg_inc = addi %arg0, %cst_1_2 : i32
   return %arg_inc : i32
 }
 
 func @complex_cond() -> i1
 
-// CHECK-LABEL: func @complex_callee(
-func @complex_callee(%arg0 : i32) -> i32 attributes { sym_visibility = "private" } {
+// CHECK-LABEL: func private @complex_callee(
+func private @complex_callee(%arg0 : i32) -> i32 {
   // CHECK: %[[CST:.*]] = constant 1 : i32
 
   %loop_cond = call @complex_cond() : () -> i1
   cond_br %loop_cond, ^bb1, ^bb2
 
 ^bb1:
   // CHECK: ^bb1:
   // CHECK-NEXT: return %[[CST]] : i32

mlir/test/Transforms/test-symbol-dce.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -symbol-dce -split-input-file -verify-diagnostics | FileCheck %s
 // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="module(symbol-dce)" -split-input-file | FileCheck %s --check-prefix=NESTED
 
 // Check that trivially dead and trivially live non-nested cases are handled.
 
 // CHECK-LABEL: module attributes {test.simple}
 module attributes {test.simple} {
-  // CHECK-NOT: func @dead_private_function
-  func @dead_private_function() attributes { sym_visibility = "private" }
+  // CHECK-NOT: func private @dead_private_function
+  func private @dead_private_function()
 
-  // CHECK-NOT: func @dead_nested_function
-  func @dead_nested_function() attributes { sym_visibility = "nested" }
+  // CHECK-NOT: func nested @dead_nested_function
+  func nested @dead_nested_function()
 
-  // CHECK: func @live_private_function
-  func @live_private_function() attributes { sym_visibility = "private" }
+  // CHECK: func private @live_private_function
+  func private @live_private_function()
 
-  // CHECK: func @live_nested_function
-  func @live_nested_function() attributes { sym_visibility = "nested" }
+  // CHECK: func nested @live_nested_function
+  func nested @live_nested_function()
 
   // CHECK: func @public_function
   func @public_function() {
     "foo.return"() {uses = [@live_private_function, @live_nested_function]} : () -> ()
   }
 
-  // CHECK: func @public_function_explicit
-  func @public_function_explicit() attributes { sym_visibility = "public" }
+  // CHECK: func public @public_function_explicit
+  func public @public_function_explicit()
 }
 
 // -----
 
 // Check that we don't DCE nested symbols if they are used.
 // CHECK-LABEL: module attributes {test.nested}
 module attributes {test.nested} {
   // CHECK: module @public_module
   module @public_module {
-    // CHECK-NOT: func @dead_nested_function
-    func @dead_nested_function() attributes { sym_visibility = "nested" }
+    // CHECK-NOT: func nested @dead_nested_function
+    func nested @dead_nested_function()
 
-    // CHECK: func @private_function
-    func @private_function() attributes { sym_visibility = "private" }
+    // CHECK: func private @private_function
+    func private @private_function()
 
-    // CHECK: func @nested_function
-    func @nested_function() attributes { sym_visibility = "nested" } {
+    // CHECK: func nested @nested_function
+    func nested @nested_function() {
       "foo.return"() {uses = [@private_function]} : () -> ()
     }
   }
 
   "live.user"() {uses = [@public_module::@nested_function]} : () -> ()
 }
 
 // -----
 
 // Check that we don't DCE symbols if we can't prove that the top-level symbol
 // table that we are running on is hidden from above.
 // NESTED-LABEL: module attributes {test.no_dce_non_hidden_parent}
 module attributes {test.no_dce_non_hidden_parent} {
   // NESTED: module @public_module
   module @public_module {
-    // NESTED: func @nested_function
-    func @nested_function() attributes { sym_visibility = "nested" }
+    // NESTED: func nested @nested_function
+    func nested @nested_function()
   }
   // NESTED: module @nested_module
   module @nested_module attributes { sym_visibility = "nested" } {
-    // NESTED: func @nested_function
-    func @nested_function() attributes { sym_visibility = "nested" }
+    // NESTED: func nested @nested_function
+    func nested @nested_function()
   }
 
   // Only private modules can be assumed to be hidden.
   // NESTED: module @private_module
   module @private_module attributes { sym_visibility = "private" } {
-    // NESTED-NOT: func @nested_function
-    func @nested_function() attributes { sym_visibility = "nested" }
+    // NESTED-NOT: func nested @nested_function
+    func nested @nested_function()
   }
 
   "live.user"() {uses = [@nested_module, @private_module]} : () -> ()
 }
 
 // -----
 
 module {
-  func @private_symbol() attributes { sym_visibility = "private" }
+  func private @private_symbol()
 
   // expected-error@+1 {{contains potentially unknown symbol table}}
   "foo.possibly_unknown_symbol_table"() ({
   }) : () -> ()
 }
 
 // -----
 
 module {
   // expected-error@+1 {{unable to resolve reference to symbol}}
   "live.user"() {uses = [@unknown_symbol]} : () -> ()
 }

mlir/test/mlir-reduce/dce-test.mlir

 // UNSUPPORTED: system-windows
 // RUN: mlir-reduce %s -test %S/failure-test.sh -pass-test DCE | FileCheck %s
 // This input should be reduced by the pass pipeline so that only
 // the @simple1 function remains as the other functions should be
 // removed by the dead code elimination pass.
 // CHECK-LABEL: func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
 
 // CHECK-NOT: func @dead_nested_function
-func @dead_private_function() attributes { sym_visibility = "private" }
+func private @dead_private_function()
 
 // CHECK-NOT: func @dead_nested_function
-func @dead_nested_function() attributes { sym_visibility = "nested" }
+func nested @dead_nested_function()
 
 func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   "test.crashOp" () : () -> ()
   return
 }