[mlir] Replace toy::DeadFunctionEliminationPass with symbolDCEPass.

[rriddle]

Summary

The dead function elimination pass in toy was a temporary stopgap until we had proper dead function elimination support in MLIR. Now that this functionality is available, this pass is no longer necessary.

Depends On D72482

[merge_guards_bot]

Unit tests: pass. 61737 tests passed, 0 failed and 779 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[mehdi_amini]

mlir/examples/toy/Ch7/CMakeLists.txt

17

This file should get deleted also right?

[rriddle]

Resolve comments

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

mlir/examples/toy/Ch4/CMakeLists.txt

 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
 mlir_tablegen(ToyCombine.inc -gen-rewriters "-I${CMAKE_CURRENT_SOURCE_DIR}/include")
 add_public_tablegen_target(ToyCh4CombineIncGen)
 
 add_toy_chapter(toyc-ch4
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
-  mlir/DeadFunctionEliminationPass.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
   )
 
 add_dependencies(toyc-ch4 ToyCh4OpsIncGen)
 add_dependencies(toyc-ch4 ToyCh4ShapeInferenceInterfaceIncGen)
 add_dependencies(toyc-ch4 ToyCh4CombineIncGen)
 add_dependencies(toyc-ch4 MLIRCallOpInterfacesIncGen)

mlir/examples/toy/Ch4/include/toy/Passes.h

 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
 std::unique_ptr<Pass> createShapeInferencePass();
-std::unique_ptr<Pass> createDeadFunctionEliminationPass();
 } // end namespace toy
 } // end namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

mlir/examples/toy/Ch4/mlir/DeadFunctionEliminationPass.cpp

-//===- DeadFunctionEliminationPass.cpp - Eliminate inlined functions ------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements a Module level pass performing dead function
-// elimination. This is required as a post-processing step after function
-// inlining.
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Analysis/Verifier.h"
-#include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/IR/OpDefinition.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Pass/Pass.h"
-#include "mlir/Support/LogicalResult.h"
-#include "toy/Passes.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
-
-namespace {
-/// This is a simple function DCE pass that deletes all non-main functions after
-/// inlining.
-/// TODO(riverriddle) This is only necessary because MLIR currently does not
-/// have generic DCE support for functions.
-class DeadFunctionEliminationPass
-    : public mlir::ModulePass<DeadFunctionEliminationPass> {
-public:
-  void runOnModule() override {
-    mlir::ModuleOp module = getModule();
-    mlir::SymbolTable moduleSymTable(module);
-
-    // Eliminate non-main functions.
-    auto mainFn = moduleSymTable.lookup<mlir::FuncOp>("main");
-    for (mlir::FuncOp func :
-         llvm::make_early_inc_range(module.getOps<mlir::FuncOp>())) {
-      if (func != mainFn)
-        func.erase();
-    }
-  }
-};
-} // end anonymous namespace
-
-/// Create a pass that eliminates inlined functions in toy.
-std::unique_ptr<mlir::Pass> mlir::toy::createDeadFunctionEliminationPass() {
-  return std::make_unique<DeadFunctionEliminationPass>();
-}

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

if (!returnOp) {
       builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
     } else if (returnOp.hasOperand()) {
       // Otherwise, if this return operation has an operand then add a result to
       // the function.
       function.setType(builder.getFunctionType(function.getType().getInputs(),
                                                getType(VarType{})));
     }
 
+    // If this function isn't main, then set the visibility to private.
+    if (funcAST.getProto()->getName() != "main")
+      function.setVisibility(mlir::FuncOp::Visibility::Private);
+
     return function;
   }
 
   /// Emit a binary operation
   mlir::Value mlirGen(BinaryExprAST &binop) {
     // First emit the operations for each side of the operation before emitting
     // the operation itself. For example if the expression is `a + foo(a)`
     // 1) First it will visiting the LHS, which will return a reference to the

mlir/examples/toy/Ch4/toyc.cpp

int dumpMLIR() {
 
   if (enableOpt) {
     mlir::PassManager pm(&context);
     // Apply any generic pass manager command line options and run the pipeline.
     applyPassManagerCLOptions(pm);
 
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
-    pm.addPass(mlir::toy::createDeadFunctionEliminationPass());
+    pm.addPass(mlir::createSymbolDCEPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
     mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 

mlir/examples/toy/Ch5/CMakeLists.txt

 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
 mlir_tablegen(ToyCombine.inc -gen-rewriters "-I${CMAKE_CURRENT_SOURCE_DIR}/include")
 add_public_tablegen_target(ToyCh5CombineIncGen)
 
 add_toy_chapter(toyc-ch5
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
-  mlir/DeadFunctionEliminationPass.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
   )
 
 add_dependencies(toyc-ch5 ToyCh5ShapeInferenceInterfaceIncGen)
 add_dependencies(toyc-ch5 ToyCh5OpsIncGen)
 add_dependencies(toyc-ch5 ToyCh5CombineIncGen)

mlir/examples/toy/Ch5/include/toy/Passes.h

 #define MLIR_TUTORIAL_TOY_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
-std::unique_ptr<Pass> createDeadFunctionEliminationPass();
 std::unique_ptr<Pass> createShapeInferencePass();
 
 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
 } // end namespace toy
 } // end namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

mlir/examples/toy/Ch5/mlir/DeadFunctionEliminationPass.cpp

-//===- DeadFunctionEliminationPass.cpp - Eliminate inlined functions ------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements a Module level pass performing dead function
-// elimination. This is required as a post-processing step after function
-// inlining.
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Analysis/Verifier.h"
-#include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/IR/OpDefinition.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Pass/Pass.h"
-#include "mlir/Support/LogicalResult.h"
-#include "toy/Passes.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
-
-namespace {
-/// This is a simple function DCE pass that deletes all non-main functions after
-/// inlining.
-/// TODO(riverriddle) This is only necessary because MLIR currently does not
-/// have generic DCE support for functions.
-class DeadFunctionEliminationPass
-    : public mlir::ModulePass<DeadFunctionEliminationPass> {
-public:
-  void runOnModule() override {
-    mlir::ModuleOp module = getModule();
-    mlir::SymbolTable moduleSymTable(module);
-
-    // Eliminate non-main functions.
-    auto mainFn = moduleSymTable.lookup<mlir::FuncOp>("main");
-    for (mlir::FuncOp func :
-         llvm::make_early_inc_range(module.getOps<mlir::FuncOp>())) {
-      if (func != mainFn)
-        func.erase();
-    }
-  }
-};
-} // end anonymous namespace
-
-/// Create a pass that eliminates inlined functions in toy.
-std::unique_ptr<mlir::Pass> mlir::toy::createDeadFunctionEliminationPass() {
-  return std::make_unique<DeadFunctionEliminationPass>();
-}

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

if (!returnOp) {
       builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
     } else if (returnOp.hasOperand()) {
       // Otherwise, if this return operation has an operand then add a result to
       // the function.
       function.setType(builder.getFunctionType(function.getType().getInputs(),
                                                getType(VarType{})));
     }
 
+    // If this function isn't main, then set the visibility to private.
+    if (funcAST.getProto()->getName() != "main")
+      function.setVisibility(mlir::FuncOp::Visibility::Private);
+
     return function;
   }
 
   /// Emit a binary operation
   mlir::Value mlirGen(BinaryExprAST &binop) {
     // First emit the operations for each side of the operation before emitting
     // the operation itself. For example if the expression is `a + foo(a)`
     // 1) First it will visiting the LHS, which will return a reference to the

mlir/examples/toy/Ch5/toyc.cpp

int dumpMLIR() {
   applyPassManagerCLOptions(pm);
 
   // Check to see what granularity of MLIR we are compiling to.
   bool isLoweringToAffine = emitAction >= Action::DumpMLIRAffine;
 
   if (enableOpt || isLoweringToAffine) {
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
-    pm.addPass(mlir::toy::createDeadFunctionEliminationPass());
+    pm.addPass(mlir::createSymbolDCEPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
     mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
   }

mlir/examples/toy/Ch6/CMakeLists.txt

 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Core
   Support
   )
 
 set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
 mlir_tablegen(ToyCombine.inc -gen-rewriters "-I${CMAKE_CURRENT_SOURCE_DIR}/include")
 add_public_tablegen_target(ToyCh6CombineIncGen)
 
 add_toy_chapter(toyc-ch6
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
-  mlir/DeadFunctionEliminationPass.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/LowerToLLVM.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
   )
 
 add_dependencies(toyc-ch6 ToyCh6ShapeInferenceInterfaceIncGen)
 add_dependencies(toyc-ch6 ToyCh6OpsIncGen)

mlir/examples/toy/Ch6/include/toy/Passes.h

 #define MLIR_TUTORIAL_TOY_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
-std::unique_ptr<Pass> createDeadFunctionEliminationPass();
 std::unique_ptr<Pass> createShapeInferencePass();
 
 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
 /// Create a pass for lowering operations the remaining `Toy` operations, as
 /// well as `Affine` and `Std`, to the LLVM dialect for codegen.
 std::unique_ptr<mlir::Pass> createLowerToLLVMPass();
 
 } // end namespace toy
 } // end namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

mlir/examples/toy/Ch6/mlir/DeadFunctionEliminationPass.cpp

-//===- DeadFunctionEliminationPass.cpp - Eliminate inlined functions ------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements a Module level pass performing dead function
-// elimination. This is required as a post-processing step after function
-// inlining.
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Analysis/Verifier.h"
-#include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/IR/OpDefinition.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Pass/Pass.h"
-#include "mlir/Support/LogicalResult.h"
-#include "toy/Passes.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
-
-namespace {
-/// This is a simple function DCE pass that deletes all non-main functions after
-/// inlining.
-/// TODO(riverriddle) This is only necessary because MLIR currently does not
-/// have generic DCE support for functions.
-class DeadFunctionEliminationPass
-    : public mlir::ModulePass<DeadFunctionEliminationPass> {
-public:
-  void runOnModule() override {
-    mlir::ModuleOp module = getModule();
-    mlir::SymbolTable moduleSymTable(module);
-
-    // Eliminate non-main functions.
-    auto mainFn = moduleSymTable.lookup<mlir::FuncOp>("main");
-    for (mlir::FuncOp func :
-         llvm::make_early_inc_range(module.getOps<mlir::FuncOp>())) {
-      if (func != mainFn)
-        func.erase();
-    }
-  }
-};
-} // end anonymous namespace
-
-/// Create a pass that eliminates inlined functions in toy.
-std::unique_ptr<mlir::Pass> mlir::toy::createDeadFunctionEliminationPass() {
-  return std::make_unique<DeadFunctionEliminationPass>();
-}

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

if (!returnOp) {
       builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
     } else if (returnOp.hasOperand()) {
       // Otherwise, if this return operation has an operand then add a result to
       // the function.
       function.setType(builder.getFunctionType(function.getType().getInputs(),
                                                getType(VarType{})));
     }
 
+    // If this function isn't main, then set the visibility to private.
+    if (funcAST.getProto()->getName() != "main")
+      function.setVisibility(mlir::FuncOp::Visibility::Private);
+
     return function;
   }
 
   /// Emit a binary operation
   mlir::Value mlirGen(BinaryExprAST &binop) {
     // First emit the operations for each side of the operation before emitting
     // the operation itself. For example if the expression is `a + foo(a)`
     // 1) First it will visiting the LHS, which will return a reference to the

mlir/examples/toy/Ch6/toyc.cpp

int loadAndProcessMLIR(mlir::MLIRContext &context,
 
   // Check to see what granularity of MLIR we are compiling to.
   bool isLoweringToAffine = emitAction >= Action::DumpMLIRAffine;
   bool isLoweringToLLVM = emitAction >= Action::DumpMLIRLLVM;
 
   if (enableOpt || isLoweringToAffine) {
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
-    pm.addPass(mlir::toy::createDeadFunctionEliminationPass());
+    pm.addPass(mlir::createSymbolDCEPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
     mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
   }

mlir/examples/toy/Ch7/CMakeLists.txt

 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Core
   Support
   )
 
 set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
 mlir_tablegen(ToyCombine.inc -gen-rewriters "-I${CMAKE_CURRENT_SOURCE_DIR}/include")
 add_public_tablegen_target(ToyCh7CombineIncGen)
 
 add_toy_chapter(toyc-ch7
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
-  mlir/DeadFunctionEliminationPass.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/LowerToLLVM.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
   )
 
 add_dependencies(toyc-ch7 ToyCh7ShapeInferenceInterfaceIncGen)
 add_dependencies(toyc-ch7 ToyCh7OpsIncGen)

mlir/examples/toy/Ch7/include/toy/Passes.h

 #define MLIR_TUTORIAL_TOY_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
-std::unique_ptr<Pass> createDeadFunctionEliminationPass();
 std::unique_ptr<Pass> createShapeInferencePass();
 
 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
 /// Create a pass for lowering operations the remaining `Toy` operations, as
 /// well as `Affine` and `Std`, to the LLVM dialect for codegen.
 std::unique_ptr<mlir::Pass> createLowerToLLVMPass();
 
 } // end namespace toy
 } // end namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

mlir/examples/toy/Ch7/mlir/DeadFunctionEliminationPass.cpp

-//===- DeadFunctionEliminationPass.cpp - Eliminate inlined functions ------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements a Module level pass performing dead function
-// elimination. This is required as a post-processing step after function
-// inlining.
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Analysis/Verifier.h"
-#include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/IR/OpDefinition.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Pass/Pass.h"
-#include "mlir/Support/LogicalResult.h"
-#include "toy/Passes.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
-
-namespace {
-/// This is a simple function DCE pass that deletes all non-main functions after
-/// inlining.
-/// TODO(riverriddle) This is only necessary because MLIR currently does not
-/// have generic DCE support for functions.
-class DeadFunctionEliminationPass
-    : public mlir::ModulePass<DeadFunctionEliminationPass> {
-public:
-  void runOnModule() override {
-    mlir::ModuleOp module = getModule();
-    mlir::SymbolTable moduleSymTable(module);
-
-    // Eliminate non-main functions.
-    auto mainFn = moduleSymTable.lookup<mlir::FuncOp>("main");
-    for (mlir::FuncOp func :
-         llvm::make_early_inc_range(module.getOps<mlir::FuncOp>())) {
-      if (func != mainFn)
-        func.erase();
-    }
-  }
-};
-} // end anonymous namespace
-
-/// Create a pass that eliminates inlined functions in toy.
-std::unique_ptr<mlir::Pass> mlir::toy::createDeadFunctionEliminationPass() {
-  return std::make_unique<DeadFunctionEliminationPass>();
-}

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

if (!returnOp) {
       builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
     } else if (returnOp.hasOperand()) {
       // Otherwise, if this return operation has an operand then add a result to
       // the function.
       function.setType(builder.getFunctionType(function.getType().getInputs(),
                                                *returnOp.operand_type_begin()));
     }
 
+    // If this function isn't main, then set the visibility to private.
+    if (funcAST.getProto()->getName() != "main")
+      function.setVisibility(mlir::FuncOp::Visibility::Private);
+
     return function;
   }
 
   /// Return the struct type that is the result of the given expression, or null
   /// if it cannot be inferred.
   StructAST *getStructFor(ExprAST *expr) {
     llvm::StringRef structName;
     if (auto *decl = llvm::dyn_cast<VariableExprAST>(expr)) {

mlir/examples/toy/Ch7/toyc.cpp

int loadAndProcessMLIR(mlir::MLIRContext &context,
 
   // Check to see what granularity of MLIR we are compiling to.
   bool isLoweringToAffine = emitAction >= Action::DumpMLIRAffine;
   bool isLoweringToLLVM = emitAction >= Action::DumpMLIRLLVM;
 
   if (enableOpt || isLoweringToAffine) {
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
-    pm.addPass(mlir::toy::createDeadFunctionEliminationPass());
+    pm.addPass(mlir::createSymbolDCEPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
     mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());

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> {
+func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
+    attributes { sym_visibility = "private" } {
   %0 = "toy.transpose"(%arg0) : (tensor<*xf64>) -> tensor<*xf64>
   %1 = "toy.transpose"(%arg1) : (tensor<*xf64>) -> tensor<*xf64>
   %2 = "toy.mul"(%0, %1) : (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
   "toy.return"(%2) : (tensor<*xf64>) -> ()
 }
 func @main() {
   %0 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64>
   %1 = "toy.reshape"(%0) : (tensor<2x3xf64>) -> tensor<2x3xf64>

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> {
+func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
+    attributes { sym_visibility = "private" } {
   %0 = "toy.transpose"(%arg0) : (tensor<*xf64>) -> tensor<*xf64>
   %1 = "toy.transpose"(%arg1) : (tensor<*xf64>) -> tensor<*xf64>
   %2 = "toy.mul"(%0, %1) : (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
   "toy.return"(%2) : (tensor<*xf64>) -> ()
 }
 func @main() {
   %0 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64>
   %1 = "toy.reshape"(%0) : (tensor<2x3xf64>) -> tensor<2x3xf64>

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> {
+func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
+    attributes { sym_visibility = "private" } {
   %0 = "toy.transpose"(%arg0) : (tensor<*xf64>) -> tensor<*xf64>
   %1 = "toy.transpose"(%arg1) : (tensor<*xf64>) -> tensor<*xf64>
   %2 = "toy.mul"(%0, %1) : (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
   "toy.return"(%2) : (tensor<*xf64>) -> ()
 }
 func @main() {
   %0 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64>
   %1 = "toy.reshape"(%0) : (tensor<2x3xf64>) -> tensor<2x3xf64>

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> {
+func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64>
+    attributes { sym_visibility = "private" } {
   %0 = "toy.transpose"(%arg0) : (tensor<*xf64>) -> tensor<*xf64>
   %1 = "toy.transpose"(%arg1) : (tensor<*xf64>) -> tensor<*xf64>
   %2 = "toy.mul"(%0, %1) : (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
   "toy.return"(%2) : (tensor<*xf64>) -> ()
 }
 func @main() {
   %0 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64>
   %1 = "toy.reshape"(%0) : (tensor<2x3xf64>) -> tensor<2x3xf64>

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

-# RUN: toyc-ch7 %s -emit=mlir 2>&1
+# RUN: toyc-ch7 %s -emit=mlir 2>&1 | FileCheck %s
 # RUN: toyc-ch7 %s -emit=mlir -opt 2>&1 | FileCheck %s --check-prefix=OPT
 
 struct Struct {
   var a;
   var b;
 }
 
 # User defined generic function may operate on struct types as well.
 def multiply_transpose(Struct value) {
   # We can access the elements of a struct via the '.' operator.
   return transpose(value.a) * transpose(value.b);
 }
 
 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-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]]) {index = 0 : i64} : (!toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_2:%.*]] = "toy.transpose"([[VAL_1]]) : (tensor<*xf64>) -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_3:%.*]] = "toy.struct_access"([[VAL_0]]) {index = 1 : i64} : (!toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_4:%.*]] = "toy.transpose"([[VAL_3]]) : (tensor<*xf64>) -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_5:%.*]] = "toy.mul"([[VAL_2]], [[VAL_4]]) : (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
 # CHECK-NEXT:      "toy.return"([[VAL_5]]) : (tensor<*xf64>) -> ()
 
 # CHECK-LABEL:   func @main()