Apply clang-tidy fixes for llvm-header-guard in MLIR (NFC)

[rriddle]

Nice!

[jsetoain]

mlir/lib/Bindings/Python/Globals.h

9–10 ↗

(On Diff #399782)

You've got some spillage over here (and several other files) :-)

[mehdi_amini]

mlir/lib/Bindings/Python/Globals.h

9–10 ↗

(On Diff #399782)

Thanks for catching this, I need to look into what's wrong in the clang-tidy config (that may be a CMake thing instead?).

Seems like it is like this for all the files in lib/..

[mehdi_amini]

Limit the change to the public include directory

[jsetoain]

Did you rename your LLVM source directory to something other than "llvm-project" (case sensitive)? That will mess up the bit of the code that figures out the guard name (check HeaderGuardCheck.cpp).

mlir/examples/toy/Ch1/include/toy/AST.h

 //===- AST.h - Node definition for the Toy AST ----------------------------===//
 //
 // 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 the AST for the Toy language. It is optimized for
 // simplicity, not efficiency. The AST forms a tree structure where each node
 // references its children using std::unique_ptr<>.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_AST_H_
-#define MLIR_TUTORIAL_TOY_AST_H_
+#ifndef TOY_AST_H
+#define TOY_AST_H
 
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <vector>
 
public:
   auto begin() -> decltype(functions.begin()) { return functions.begin(); }
   auto end() -> decltype(functions.end()) { return functions.end(); }
 };
 
 void dump(ModuleAST &);
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_AST_H_
+#endif // TOY_AST_H

mlir/examples/toy/Ch1/include/toy/Lexer.h

 //===- Lexer.h - Lexer for the Toy language -------------------------------===//
 //
 // 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 simple Lexer for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_LEXER_H_
-#define MLIR_TUTORIAL_TOY_LEXER_H_
+#ifndef TOY_LEXER_H
+#define TOY_LEXER_H
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 #include <string>
 
 namespace toy {
 
if (current <= end && *current)
       ++current;
     llvm::StringRef result{begin, static_cast<size_t>(current - begin)};
     return result;
   }
   const char *current, *end;
 };
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_LEXER_H_
+#endif // TOY_LEXER_H

mlir/examples/toy/Ch1/include/toy/Parser.h

 //===- Parser.h - Toy Language Parser -------------------------------------===//
 //
 // 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 the parser for the Toy language. It processes the Token
 // provided by the Lexer and returns an AST.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PARSER_H
-#define MLIR_TUTORIAL_TOY_PARSER_H
+#ifndef TOY_PARSER_H
+#define TOY_PARSER_H
 
 #include "toy/AST.h"
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (isprint(curToken))
       llvm::errs() << " '" << (char)curToken << "'";
     llvm::errs() << "\n";
     return nullptr;
   }
 };
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_PARSER_H
+#endif // TOY_PARSER_H

mlir/examples/toy/Ch2/include/toy/AST.h

 //===- AST.h - Node definition for the Toy AST ----------------------------===//
 //
 // 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 the AST for the Toy language. It is optimized for
 // simplicity, not efficiency. The AST forms a tree structure where each node
 // references its children using std::unique_ptr<>.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_AST_H_
-#define MLIR_TUTORIAL_TOY_AST_H_
+#ifndef TOY_AST_H
+#define TOY_AST_H
 
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <vector>
 
public:
   auto begin() -> decltype(functions.begin()) { return functions.begin(); }
   auto end() -> decltype(functions.end()) { return functions.end(); }
 };
 
 void dump(ModuleAST &);
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_AST_H_
+#endif // TOY_AST_H

mlir/examples/toy/Ch2/include/toy/Lexer.h

 //===- Lexer.h - Lexer for the Toy language -------------------------------===//
 //
 // 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 simple Lexer for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_LEXER_H_
-#define MLIR_TUTORIAL_TOY_LEXER_H_
+#ifndef TOY_LEXER_H
+#define TOY_LEXER_H
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 #include <string>
 
 namespace toy {
 
if (current <= end && *current)
       ++current;
     llvm::StringRef result{begin, static_cast<size_t>(current - begin)};
     return result;
   }
   const char *current, *end;
 };
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_LEXER_H_
+#endif // TOY_LEXER_H

mlir/examples/toy/Ch2/include/toy/MLIRGen.h

 //===- MLIRGen.h - MLIR Generation from a Toy AST -------------------------===//
 //
 // 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 declares a simple interface to perform IR generation targeting MLIR
 // from a Module AST for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_MLIRGEN_H_
-#define MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#ifndef TOY_MLIRGEN_H
+#define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
 class OwningModuleRef;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
 mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch2/include/toy/Parser.h

 //===- Parser.h - Toy Language Parser -------------------------------------===//
 //
 // 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 the parser for the Toy language. It processes the Token
 // provided by the Lexer and returns an AST.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PARSER_H
-#define MLIR_TUTORIAL_TOY_PARSER_H
+#ifndef TOY_PARSER_H
+#define TOY_PARSER_H
 
 #include "toy/AST.h"
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (isprint(curToken))
       llvm::errs() << " '" << (char)curToken << "'";
     llvm::errs() << "\n";
     return nullptr;
   }
 };
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_PARSER_H
+#endif // TOY_PARSER_H

mlir/examples/toy/Ch3/include/toy/AST.h

 //===- AST.h - Node definition for the Toy AST ----------------------------===//
 //
 // 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 the AST for the Toy language. It is optimized for
 // simplicity, not efficiency. The AST forms a tree structure where each node
 // references its children using std::unique_ptr<>.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_AST_H_
-#define MLIR_TUTORIAL_TOY_AST_H_
+#ifndef TOY_AST_H
+#define TOY_AST_H
 
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <vector>
 
public:
   auto begin() -> decltype(functions.begin()) { return functions.begin(); }
   auto end() -> decltype(functions.end()) { return functions.end(); }
 };
 
 void dump(ModuleAST &);
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_AST_H_
+#endif // TOY_AST_H

mlir/examples/toy/Ch3/include/toy/Lexer.h

 //===- Lexer.h - Lexer for the Toy language -------------------------------===//
 //
 // 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 simple Lexer for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_LEXER_H_
-#define MLIR_TUTORIAL_TOY_LEXER_H_
+#ifndef TOY_LEXER_H
+#define TOY_LEXER_H
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 #include <string>
 
 namespace toy {
 
if (current <= end && *current)
       ++current;
     llvm::StringRef result{begin, static_cast<size_t>(current - begin)};
     return result;
   }
   const char *current, *end;
 };
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_LEXER_H_
+#endif // TOY_LEXER_H

mlir/examples/toy/Ch3/include/toy/MLIRGen.h

 //===- MLIRGen.h - MLIR Generation from a Toy AST -------------------------===//
 //
 // 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 declares a simple interface to perform IR generation targeting MLIR
 // from a Module AST for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_MLIRGEN_H_
-#define MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#ifndef TOY_MLIRGEN_H
+#define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
 class OwningModuleRef;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
 mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#endif // TOY_MLIRGEN_H

mlir/examples/toy/Ch3/include/toy/Parser.h

 //===- Parser.h - Toy Language Parser -------------------------------------===//
 //
 // 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 the parser for the Toy language. It processes the Token
 // provided by the Lexer and returns an AST.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PARSER_H
-#define MLIR_TUTORIAL_TOY_PARSER_H
+#ifndef TOY_PARSER_H
+#define TOY_PARSER_H
 
 #include "toy/AST.h"
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (isprint(curToken))
       llvm::errs() << " '" << (char)curToken << "'";
     llvm::errs() << "\n";
     return nullptr;
   }
 };
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_PARSER_H
+#endif // TOY_PARSER_H

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

 //===- AST.h - Node definition for the Toy AST ----------------------------===//
 //
 // 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 the AST for the Toy language. It is optimized for
 // simplicity, not efficiency. The AST forms a tree structure where each node
 // references its children using std::unique_ptr<>.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_AST_H_
-#define MLIR_TUTORIAL_TOY_AST_H_
+#ifndef TOY_AST_H
+#define TOY_AST_H
 
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <vector>
 
public:
   auto begin() -> decltype(functions.begin()) { return functions.begin(); }
   auto end() -> decltype(functions.end()) { return functions.end(); }
 };
 
 void dump(ModuleAST &);
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_AST_H_
+#endif // TOY_AST_H

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

 //===- Lexer.h - Lexer for the Toy language -------------------------------===//
 //
 // 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 simple Lexer for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_LEXER_H_
-#define MLIR_TUTORIAL_TOY_LEXER_H_
+#ifndef TOY_LEXER_H
+#define TOY_LEXER_H
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 #include <string>
 
 namespace toy {
 
if (current <= end && *current)
       ++current;
     llvm::StringRef result{begin, static_cast<size_t>(current - begin)};
     return result;
   }
   const char *current, *end;
 };
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_LEXER_H_
+#endif // TOY_LEXER_H

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

 //===- MLIRGen.h - MLIR Generation from a Toy AST -------------------------===//
 //
 // 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 declares a simple interface to perform IR generation targeting MLIR
 // from a Module AST for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_MLIRGEN_H_
-#define MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#ifndef TOY_MLIRGEN_H
+#define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
 class OwningModuleRef;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
 mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#endif // TOY_MLIRGEN_H

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

 //===- Parser.h - Toy Language Parser -------------------------------------===//
 //
 // 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 the parser for the Toy language. It processes the Token
 // provided by the Lexer and returns an AST.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PARSER_H
-#define MLIR_TUTORIAL_TOY_PARSER_H
+#ifndef TOY_PARSER_H
+#define TOY_PARSER_H
 
 #include "toy/AST.h"
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (isprint(curToken))
       llvm::errs() << " '" << (char)curToken << "'";
     llvm::errs() << "\n";
     return nullptr;
   }
 };
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_PARSER_H
+#endif // TOY_PARSER_H

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

 //===- Passes.h - Toy Passes Definition -----------------------------------===//
 //
 // 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 exposes the entry points to create compiler passes for Toy.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PASSES_H
-#define MLIR_TUTORIAL_TOY_PASSES_H
+#ifndef TOY_PASSES_H
+#define TOY_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
 std::unique_ptr<Pass> createShapeInferencePass();
 } // namespace toy
 } // namespace mlir
 
-#endif // MLIR_TUTORIAL_TOY_PASSES_H
+#endif // TOY_PASSES_H

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

 //===- AST.h - Node definition for the Toy AST ----------------------------===//
 //
 // 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 the AST for the Toy language. It is optimized for
 // simplicity, not efficiency. The AST forms a tree structure where each node
 // references its children using std::unique_ptr<>.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_AST_H_
-#define MLIR_TUTORIAL_TOY_AST_H_
+#ifndef TOY_AST_H
+#define TOY_AST_H
 
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <vector>
 
public:
   auto begin() -> decltype(functions.begin()) { return functions.begin(); }
   auto end() -> decltype(functions.end()) { return functions.end(); }
 };
 
 void dump(ModuleAST &);
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_AST_H_
+#endif // TOY_AST_H

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

 //===- Lexer.h - Lexer for the Toy language -------------------------------===//
 //
 // 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 simple Lexer for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_LEXER_H_
-#define MLIR_TUTORIAL_TOY_LEXER_H_
+#ifndef TOY_LEXER_H
+#define TOY_LEXER_H
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 #include <string>
 
 namespace toy {
 
if (current <= end && *current)
       ++current;
     llvm::StringRef result{begin, static_cast<size_t>(current - begin)};
     return result;
   }
   const char *current, *end;
 };
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_LEXER_H_
+#endif // TOY_LEXER_H

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

 //===- MLIRGen.h - MLIR Generation from a Toy AST -------------------------===//
 //
 // 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 declares a simple interface to perform IR generation targeting MLIR
 // from a Module AST for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_MLIRGEN_H_
-#define MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#ifndef TOY_MLIRGEN_H
+#define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
 class OwningModuleRef;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
 mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#endif // TOY_MLIRGEN_H

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

 //===- Parser.h - Toy Language Parser -------------------------------------===//
 //
 // 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 the parser for the Toy language. It processes the Token
 // provided by the Lexer and returns an AST.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PARSER_H
-#define MLIR_TUTORIAL_TOY_PARSER_H
+#ifndef TOY_PARSER_H
+#define TOY_PARSER_H
 
 #include "toy/AST.h"
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (isprint(curToken))
       llvm::errs() << " '" << (char)curToken << "'";
     llvm::errs() << "\n";
     return nullptr;
   }
 };
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_PARSER_H
+#endif // TOY_PARSER_H

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

 //===- Passes.h - Toy Passes Definition -----------------------------------===//
 //
 // 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 exposes the entry points to create compiler passes for Toy.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PASSES_H
-#define MLIR_TUTORIAL_TOY_PASSES_H
+#ifndef TOY_PASSES_H
+#define TOY_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
 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();
 
 } // namespace toy
 } // namespace mlir
 
-#endif // MLIR_TUTORIAL_TOY_PASSES_H
+#endif // TOY_PASSES_H

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

 //===- AST.h - Node definition for the Toy AST ----------------------------===//
 //
 // 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 the AST for the Toy language. It is optimized for
 // simplicity, not efficiency. The AST forms a tree structure where each node
 // references its children using std::unique_ptr<>.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_AST_H_
-#define MLIR_TUTORIAL_TOY_AST_H_
+#ifndef TOY_AST_H
+#define TOY_AST_H
 
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <vector>
 
public:
   auto begin() -> decltype(functions.begin()) { return functions.begin(); }
   auto end() -> decltype(functions.end()) { return functions.end(); }
 };
 
 void dump(ModuleAST &);
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_AST_H_
+#endif // TOY_AST_H

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

 //===- Lexer.h - Lexer for the Toy language -------------------------------===//
 //
 // 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 simple Lexer for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_LEXER_H_
-#define MLIR_TUTORIAL_TOY_LEXER_H_
+#ifndef TOY_LEXER_H
+#define TOY_LEXER_H
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 #include <string>
 
 namespace toy {
 
if (current <= end && *current)
       ++current;
     llvm::StringRef result{begin, static_cast<size_t>(current - begin)};
     return result;
   }
   const char *current, *end;
 };
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_LEXER_H_
+#endif // TOY_LEXER_H

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

 //===- MLIRGen.h - MLIR Generation from a Toy AST -------------------------===//
 //
 // 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 declares a simple interface to perform IR generation targeting MLIR
 // from a Module AST for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_MLIRGEN_H_
-#define MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#ifndef TOY_MLIRGEN_H
+#define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
 class OwningModuleRef;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
 mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#endif // TOY_MLIRGEN_H

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

 //===- Parser.h - Toy Language Parser -------------------------------------===//
 //
 // 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 the parser for the Toy language. It processes the Token
 // provided by the Lexer and returns an AST.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PARSER_H
-#define MLIR_TUTORIAL_TOY_PARSER_H
+#ifndef TOY_PARSER_H
+#define TOY_PARSER_H
 
 #include "toy/AST.h"
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (isprint(curToken))
       llvm::errs() << " '" << (char)curToken << "'";
     llvm::errs() << "\n";
     return nullptr;
   }
 };
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_PARSER_H
+#endif // TOY_PARSER_H

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

 //===- Passes.h - Toy Passes Definition -----------------------------------===//
 //
 // 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 exposes the entry points to create compiler passes for Toy.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PASSES_H
-#define MLIR_TUTORIAL_TOY_PASSES_H
+#ifndef TOY_PASSES_H
+#define TOY_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
 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();
 
 } // namespace toy
 } // namespace mlir
 
-#endif // MLIR_TUTORIAL_TOY_PASSES_H
+#endif // TOY_PASSES_H

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

 //===- AST.h - Node definition for the Toy AST ----------------------------===//
 //
 // 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 the AST for the Toy language. It is optimized for
 // simplicity, not efficiency. The AST forms a tree structure where each node
 // references its children using std::unique_ptr<>.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_AST_H_
-#define MLIR_TUTORIAL_TOY_AST_H_
+#ifndef TOY_AST_H
+#define TOY_AST_H
 
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <vector>
 
public:
   auto begin() -> decltype(records.begin()) { return records.begin(); }
   auto end() -> decltype(records.end()) { return records.end(); }
 };
 
 void dump(ModuleAST &);
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_AST_H_
+#endif // TOY_AST_H

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

 //===- Lexer.h - Lexer for the Toy language -------------------------------===//
 //
 // 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 simple Lexer for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_LEXER_H_
-#define MLIR_TUTORIAL_TOY_LEXER_H_
+#ifndef TOY_LEXER_H
+#define TOY_LEXER_H
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 #include <string>
 
 namespace toy {
 
if (current <= end && *current)
       ++current;
     llvm::StringRef result{begin, static_cast<size_t>(current - begin)};
     return result;
   }
   const char *current, *end;
 };
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_LEXER_H_
+#endif // TOY_LEXER_H

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

 //===- MLIRGen.h - MLIR Generation from a Toy AST -------------------------===//
 //
 // 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 declares a simple interface to perform IR generation targeting MLIR
 // from a Module AST for the Toy language.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_MLIRGEN_H_
-#define MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#ifndef TOY_MLIRGEN_H
+#define TOY_MLIRGEN_H
 
 #include <memory>
 
 namespace mlir {
 class MLIRContext;
 class OwningModuleRef;
 } // namespace mlir
 
 namespace toy {
 class ModuleAST;
 
 /// Emit IR for the given Toy moduleAST, returns a newly created MLIR module
 /// or nullptr on failure.
 mlir::OwningModuleRef mlirGen(mlir::MLIRContext &context, ModuleAST &moduleAST);
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_MLIRGEN_H_
+#endif // TOY_MLIRGEN_H

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

 //===- Parser.h - Toy Language Parser -------------------------------------===//
 //
 // 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 the parser for the Toy language. It processes the Token
 // provided by the Lexer and returns an AST.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PARSER_H
-#define MLIR_TUTORIAL_TOY_PARSER_H
+#ifndef TOY_PARSER_H
+#define TOY_PARSER_H
 
 #include "toy/AST.h"
 #include "toy/Lexer.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (isprint(curToken))
       llvm::errs() << " '" << (char)curToken << "'";
     llvm::errs() << "\n";
     return nullptr;
   }
 };
 
 } // namespace toy
 
-#endif // MLIR_TUTORIAL_TOY_PARSER_H
+#endif // TOY_PARSER_H

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

 //===- Passes.h - Toy Passes Definition -----------------------------------===//
 //
 // 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 exposes the entry points to create compiler passes for Toy.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TUTORIAL_TOY_PASSES_H
-#define MLIR_TUTORIAL_TOY_PASSES_H
+#ifndef TOY_PASSES_H
+#define TOY_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
 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();
 
 } // namespace toy
 } // namespace mlir
 
-#endif // MLIR_TUTORIAL_TOY_PASSES_H
+#endif // TOY_PASSES_H

mlir/include/mlir-c/Conversion.h

 //===-- mlir-c/Conversion.h - Conversion passes initialization ----*- C -*-===//
 //
 // 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 header declares the registration and creation method for conversion
 // passes.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_C_CONVERSIONS_H
-#define MLIR_C_CONVERSIONS_H
+#ifndef MLIR_C_CONVERSION_H
+#define MLIR_C_CONVERSION_H
 
 #include "mlir-c/Support.h"
 
 #include "mlir/Conversion/Passes.capi.h.inc"
 
-#endif // MLIR_C_CONVERSIONS_H
+#endif // MLIR_C_CONVERSION_H

mlir/include/mlir-c/Dialect/SparseTensor.h

 //===-- mlir-c/Dialect/SparseTensor.h - C API for SparseTensor ----*- C -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_C_DIALECT_SPARSE_TENSOR_H
-#define MLIR_C_DIALECT_SPARSE_TENSOR_H
+#ifndef MLIR_C_DIALECT_SPARSETENSOR_H
+#define MLIR_C_DIALECT_SPARSETENSOR_H
 
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/Registration.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 

 mlirSparseTensorEncodingAttrGetIndexBitWidth(MlirAttribute attr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #include "mlir/Dialect/SparseTensor/Transforms/Passes.capi.h.inc"
 
-#endif // MLIR_C_DIALECT_SPARSE_TENSOR_H
+#endif // MLIR_C_DIALECT_SPARSETENSOR_H

mlir/include/mlir-c/ExecutionEngine.h

 MLIR_CAPI_EXPORTED void
 mlirExecutionEngineDumpToObjectFile(MlirExecutionEngine jit,
                                     MlirStringRef fileName);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // EXECUTIONENGINE_H
+#endif // MLIR_C_EXECUTIONENGINE_H

mlir/include/mlir-c/Interfaces.h

 //===-- mlir-c/Interfaces.h - C API to Core MLIR IR interfaces ----*- C -*-===//
 //
 // 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 header declares the C interface to MLIR interface classes. It is
 // intended to contain interfaces defined in lib/Interfaces.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_C_DIALECT_H
-#define MLIR_C_DIALECT_H
+#ifndef MLIR_C_INTERFACES_H
+#define MLIR_C_INTERFACES_H
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
MLIR_CAPI_EXPORTED MlirLogicalResult mlirInferTypeOpInterfaceInferReturnTypes(
     intptr_t nOperands, MlirValue *operands, MlirAttribute attributes,
     intptr_t nRegions, MlirRegion *regions, MlirTypesCallback callback,
     void *userData);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // MLIR_C_DIALECT_H
+#endif // MLIR_C_INTERFACES_H

mlir/include/mlir/Analysis/AffineAnalysis.h

 //===- AffineAnalysis.h - analyses for affine structures --------*- C++ -*-===//
 //
 // 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 header file defines prototypes for methods that perform analysis
 // involving affine structures (AffineExprStorage, AffineMap, IntegerSet, etc.)
 // and other IR structures that in turn use these.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_AFFINE_ANALYSIS_H
-#define MLIR_ANALYSIS_AFFINE_ANALYSIS_H
+#ifndef MLIR_ANALYSIS_AFFINEANALYSIS_H
+#define MLIR_ANALYSIS_AFFINEANALYSIS_H
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {

 /// load and store ops in loop nest rooted at 'forOp', at loop depths in range
 /// [1, maxLoopDepth].
 void getDependenceComponents(
     AffineForOp forOp, unsigned maxLoopDepth,
     std::vector<SmallVector<DependenceComponent, 2>> *depCompsVec);
 
 } // namespace mlir
 
-#endif // MLIR_ANALYSIS_AFFINE_ANALYSIS_H
+#endif // MLIR_ANALYSIS_AFFINEANALYSIS_H

mlir/include/mlir/Analysis/LoopAnalysis.h

 //===- LoopAnalysis.h - loop analysis methods -------------------*- C++ -*-===//
 //
 // 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 header file defines prototypes for methods to analyze loops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_LOOP_ANALYSIS_H
-#define MLIR_ANALYSIS_LOOP_ANALYSIS_H
+#ifndef MLIR_ANALYSIS_LOOPANALYSIS_H
+#define MLIR_ANALYSIS_LOOPANALYSIS_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 
 namespace mlir {
 
 class AffineExpr;

 /// matching reductions without pre-defined semantics in core MLIR. It's up to
 /// each client to make sense out of the list of combiner operations. It's also
 /// up to each client to check for additional invariants on the expected
 /// reductions not covered by this generic matching.
 Value matchReduction(ArrayRef<BlockArgument> iterCarriedArgs, unsigned redPos,
                      SmallVectorImpl<Operation *> &combinerOps);
 } // namespace mlir
 
-#endif // MLIR_ANALYSIS_LOOP_ANALYSIS_H
+#endif // MLIR_ANALYSIS_LOOPANALYSIS_H

mlir/include/mlir/Analysis/NestedMatcher.h

 //===- NestedMacher.h - Nested matcher for Function -------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_MLFUNCTIONMATCHER_H_
-#define MLIR_ANALYSIS_MLFUNCTIONMATCHER_H_
+#ifndef MLIR_ANALYSIS_NESTEDMATCHER_H
+#define MLIR_ANALYSIS_NESTEDMATCHER_H
 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Operation.h"
 #include "llvm/Support/Allocator.h"
 
 namespace mlir {
 
 class NestedPattern;

 
 bool isParallelLoop(Operation &op);
 bool isReductionLoop(Operation &op);
 bool isLoadOrStore(Operation &op);
 
 } // namespace matcher
 } // namespace mlir
 
-#endif // MLIR_ANALYSIS_MLFUNCTIONMATCHER_H_
+#endif // MLIR_ANALYSIS_NESTEDMATCHER_H

mlir/include/mlir/Analysis/NumberOfExecutions.h

 // region is executed *each time* that region is entered. The analysis
 // iterates over all associated regions that are attached to the given top-level
 // operation.
 //
 // It is possible to query number of executions information on block level.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_NUMBER_OF_EXECUTIONS_H
-#define MLIR_ANALYSIS_NUMBER_OF_EXECUTIONS_H
+#ifndef MLIR_ANALYSIS_NUMBEROFEXECUTIONS_H
+#define MLIR_ANALYSIS_NUMBEROFEXECUTIONS_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 
 namespace mlir {
 
 class Block;
private:
   Optional<int64_t> numberOfRegionInvocations;
 
   /// Number of `block` executions *each time* parent region is invoked.
   Optional<int64_t> numberOfBlockExecutions;
 };
 
 } // namespace mlir
 
-#endif // MLIR_ANALYSIS_NUMBER_OF_EXECUTIONS_H
+#endif // MLIR_ANALYSIS_NUMBEROFEXECUTIONS_H

mlir/include/mlir/Analysis/Presburger/LinearTransform.h

 //===- LinearTransform.h - MLIR LinearTransform Class -----------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Support for linear transforms and applying them to an IntegerPolyhedron.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_LINEARTRANSFORM_H
-#define MLIR_ANALYSIS_LINEARTRANSFORM_H
+#ifndef MLIR_ANALYSIS_PRESBURGER_LINEARTRANSFORM_H
+#define MLIR_ANALYSIS_PRESBURGER_LINEARTRANSFORM_H
 
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {
 
 class LinearTransform {
public:
   // this transform, say T, and return Tv.
   SmallVector<int64_t, 8> preMultiplyColumn(ArrayRef<int64_t> colVec) const;
 
 private:
   Matrix matrix;
 };
 
 } // namespace mlir
-#endif // MLIR_ANALYSIS_LINEARTRANSFORM_H
+#endif // MLIR_ANALYSIS_PRESBURGER_LINEARTRANSFORM_H

mlir/include/mlir/Analysis/Presburger/PresburgerSet.h

 //===- Set.h - MLIR PresburgerSet Class -------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // A class to represent unions of IntegerPolyhedrons.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_ANALYSIS_PRESBURGERSET_H
-#define MLIR_ANALYSIS_PRESBURGERSET_H
+#ifndef MLIR_ANALYSIS_PRESBURGER_PRESBURGERSET_H
+#define MLIR_ANALYSIS_PRESBURGER_PRESBURGERSET_H
 
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 
 namespace mlir {
 
 /// This class can represent a union of IntegerPolyhedrons, with support for
 /// union, intersection, subtraction and complement operations, as well as
 /// sampling.
private:
   unsigned nSym;
 
   /// The list of integerPolyhedrons that this set is the union of.
   SmallVector<IntegerPolyhedron, 2> integerPolyhedrons;
 };
 
 } // namespace mlir
 
-#endif // MLIR_ANALYSIS_PRESBURGERSET_H
+#endif // MLIR_ANALYSIS_PRESBURGER_PRESBURGERSET_H

mlir/include/mlir/Bindings/Python/PybindAdaptors.h

 // implementation details of the MLIR Python API and do not introduce C++-level
 // dependencies with it (requiring only Python and CAPI-level dependencies).
 //
 // It is encouraged to be used both in-tree and out-of-tree. For in-tree use
 // cases, it should be used for dialect implementations (versus relying on
 // Pybind-based internals of the core libraries).
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_BINDINGS_PYTHON_PYBIND_ADAPTORS_H
-#define MLIR_BINDINGS_PYTHON_PYBIND_ADAPTORS_H
+#ifndef MLIR_BINDINGS_PYTHON_PYBINDADAPTORS_H
+#define MLIR_BINDINGS_PYTHON_PYBINDADAPTORS_H
 
 #include <pybind11/pybind11.h>
 #include <pybind11/pytypes.h>
 #include <pybind11/stl.h>
 
 #include "mlir-c/Bindings/Python/Interop.h"
 #include "mlir-c/IR.h"
 
def_staticmethod(
         py::arg("other_type"));
   }
 };
 
 } // namespace adaptors
 } // namespace python
 } // namespace mlir
 
-#endif // MLIR_BINDINGS_PYTHON_PYBIND_ADAPTORS_H
+#endif // MLIR_BINDINGS_PYTHON_PYBINDADAPTORS_H

mlir/include/mlir/Conversion/LLVMCommon/MemRefBuilder.h

public:
   /// Builds IR inserting the stride[index] into the descriptor.
   static void setStride(OpBuilder &builder, Location loc,
                         LLVMTypeConverter &typeConverter, Value strideBasePtr,
                         Value index, Value stride);
 };
 
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_LLVMCOMMON_MEMREFBUILDER_H_
+#endif // MLIR_CONVERSION_LLVMCOMMON_MEMREFBUILDER_H

mlir/include/mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h

 //===- LinalgToSPIRVPass.h -  Linalg to SPIR-V Passes -----------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides passes to convert Linalg dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_CONVERSION_STANDARDTOSPIRV_LINALGTOSPIRVPASS_H
-#define MLIR_CONVERSION_STANDARDTOSPIRV_LINALGTOSPIRVPASS_H
+#ifndef MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H
+#define MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 /// Creates and returns a pass to convert Linalg ops to SPIR-V ops.
 std::unique_ptr<OperationPass<ModuleOp>> createLinalgToSPIRVPass();
 
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_STANDARDTOSPIRV_LINALGTOSPIRVPASS_H
+#endif // MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H

mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h

 //===- OpenMPToLLVM.h - Utils to convert from the OpenMP dialect ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
-#ifndef MLIR_CONVERSION_OPENMPTOLLVM_OPENMPTOLLVM_H_
-#define MLIR_CONVERSION_OPENMPTOLLVM_OPENMPTOLLVM_H_
+#ifndef MLIR_CONVERSION_OPENMPTOLLVM_CONVERTOPENMPTOLLVM_H
+#define MLIR_CONVERSION_OPENMPTOLLVM_CONVERTOPENMPTOLLVM_H
 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class MLIRContext;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
 using OwningRewritePatternList = RewritePatternSet;
 
 /// Populate the given list with patterns that convert from OpenMP to LLVM.
 void populateOpenMPToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             RewritePatternSet &patterns);
 
 /// Create a pass to convert OpenMP operations to the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertOpenMPToLLVMPass();
 
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_OPENMPTOLLVM_OPENMPTOLLVM_H_
+#endif // MLIR_CONVERSION_OPENMPTOLLVM_CONVERTOPENMPTOLLVM_H

mlir/include/mlir/Conversion/VectorToGPU/VectorToGPU.h

 //===- VectorToGPU.h - Convert vector to GPU dialect ------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_INCLUDE_MLIR_CONVERSION_VECTORTOSCF_VECTORTOGPU_H_
-#define MLIR_INCLUDE_MLIR_CONVERSION_VECTORTOSCF_VECTORTOGPU_H_
+#ifndef MLIR_CONVERSION_VECTORTOGPU_VECTORTOGPU_H
+#define MLIR_CONVERSION_VECTORTOGPU_VECTORTOGPU_H
 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class MLIRContext;
 class Pass;
 class FuncOp;
 class RewritePatternSet;
 
 /// Patterns to transform vector ops into a canonical form to convert to MMA
 /// matrix operations.
 void populatePrepareVectorToMMAPatterns(RewritePatternSet &patterns);
 
 /// Convert vector ops to MMA matrix operations. This will convert slice of
 /// operations that can be legally converted to MMA operations. The rest of the
 /// vector operations are left untouched.
 void convertVectorToMMAOps(FuncOp funcOp);
 
 /// Convert from vector to GPU ops.
 std::unique_ptr<Pass> createConvertVectorToGPUPass();
 
 } // namespace mlir
 
-#endif // MLIR_INCLUDE_MLIR_CONVERSION_VECTORTOSCF_VECTORTOGPU_H_
+#endif // MLIR_CONVERSION_VECTORTOGPU_VECTORTOGPU_H

mlir/include/mlir/Conversion/VectorToSPIRV/VectorToSPIRV.h

 //=- VectorToSPIRV.h - Vector to SPIR-V Patterns ------------------*- C++ -*-=//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides patterns to convert Vector dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_INCLUDE_MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRV_H
-#define MLIR_INCLUDE_MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRV_H
+#ifndef MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRV_H
+#define MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRV_H
 
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 class SPIRVTypeConverter;
 
 /// Appends to a pattern list additional patterns for translating Vector Ops to
 /// SPIR-V ops.
 void populateVectorToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                    RewritePatternSet &patterns);
 
 } // namespace mlir
 
-#endif // MLIR_INCLUDE_MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRV_H
+#endif // MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRV_H

mlir/include/mlir/Conversion/VectorToSPIRV/VectorToSPIRVPass.h

 //=- VectorToSPIRVPass.h - Vector to SPIR-V Passes ----------------*- C++ -*-=//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides passes to convert Vector dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_CONVERSION_VECTORTOSPIRV_GPUTOSPIRVPASS_H
-#define MLIR_CONVERSION_VECTORTOSPIRV_GPUTOSPIRVPASS_H
+#ifndef MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRVPASS_H
+#define MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 /// Creates a pass to convert Vector Ops to SPIR-V ops.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertVectorToSPIRVPass();
 
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_VECTORTOSPIRV_GPUTOSPIRVPASS_H
+#endif // MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRVPASS_H

mlir/include/mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h

 //===- AffineMemoryOpInterfaces.h -------------------------------*- C++ -*-===//
 //
 // 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 contains a set of interfaces for affine memory ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPDIALECT_H_
-#define MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPDIALECT_H_
+#ifndef MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPINTERFACES_H
+#define MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPINTERFACES_H
 
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 #include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h.inc"
 } // namespace mlir
 
-#endif // MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPDIALECT_H_
+#endif // MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPINTERFACES_H

mlir/include/mlir/Dialect/Affine/Passes.h

 //===- Passes.h - Pass Entrypoints ------------------------------*- C++ -*-===//
 //
 // 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 header file defines a set of transforms specific for the AffineOps
 // dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_AFFINE_TRANSFORMS_PASSES_H
-#define MLIR_DIALECT_AFFINE_TRANSFORMS_PASSES_H
+#ifndef MLIR_DIALECT_AFFINE_PASSES_H
+#define MLIR_DIALECT_AFFINE_PASSES_H
 
 #include "mlir/Pass/Pass.h"
 #include <limits>
 
 namespace mlir {
 
 class AffineForOp;
 

 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Affine/Passes.h.inc"
 
 } // namespace mlir
 
-#endif // MLIR_DIALECT_AFFINE_RANSFORMS_PASSES_H
+#endif // MLIR_DIALECT_AFFINE_PASSES_H

mlir/include/mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h

 //===- LegalizeForExport.h - Prepare for translation to LLVM IR -*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LLVMIR_TRANSFORMS_LEGALIZE_FOR_EXPORT_H
-#define MLIR_DIALECT_LLVMIR_TRANSFORMS_LEGALIZE_FOR_EXPORT_H
+#ifndef MLIR_DIALECT_LLVMIR_TRANSFORMS_LEGALIZEFOREXPORT_H
+#define MLIR_DIALECT_LLVMIR_TRANSFORMS_LEGALIZEFOREXPORT_H
 
 #include <memory>
 
 namespace mlir {
 class Operation;
 class Pass;
 
 namespace LLVM {
 
 /// Make argument-taking successors of each block distinct.  PHI nodes in LLVM
 /// IR use the predecessor ID to identify which value to take. They do not
 /// support different values coming from the same predecessor. If a block has
 /// another block as a successor more than once with different values, insert
 /// a new dummy block for LLVM PHI nodes to tell the sources apart.
 void ensureDistinctSuccessors(Operation *op);
 
 /// Creates a pass that legalizes the LLVM dialect operations so that they can
 /// be translated to LLVM IR.
 std::unique_ptr<Pass> createLegalizeForExportPass();
 
 } // namespace LLVM
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LLVMIR_TRANSFORMS_LEGALIZE_FOR_EXPORT_H
+#endif // MLIR_DIALECT_LLVMIR_TRANSFORMS_LEGALIZEFOREXPORT_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/AffineInterfaceImpl.h

 //===- AffineInterfaceImpl.h - Affine Impl. of BufferizableOpInterface ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_AFFINE_INTERFACE_IMPL_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_AFFINE_INTERFACE_IMPL_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_AFFINEINTERFACEIMPL_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_AFFINEINTERFACEIMPL_H
 
 namespace mlir {
 
 class DialectRegistry;
 
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace affine_ext {
 
 void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
 
 } // namespace affine_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_AFFINE_INTERFACE_IMPL_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_AFFINEINTERFACEIMPL_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ArithInterfaceImpl.h

 //===- ArithInterfaceImpl.h - Arith Impl. of BufferizableOpInterface ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_ARITH_INTERFACE_IMPL_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_ARITH_INTERFACE_IMPL_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_ARITHINTERFACEIMPL_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_ARITHINTERFACEIMPL_H
 
 namespace mlir {
 
 class DialectRegistry;
 
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace arith_ext {
 
 void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
 
 } // namespace arith_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_ARITH_INTERFACE_IMPL_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_ARITHINTERFACEIMPL_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizationInterfaceImpl.h

 //===- BufferizationInterfaceImpl.h - Bufferization Impl. of Op Interface -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_BUFFERIZATION_INTERFACE_IMPL_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_BUFFERIZATION_INTERFACE_IMPL_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_BUFFERIZATIONINTERFACEIMPL_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_BUFFERIZATIONINTERFACEIMPL_H
 
 namespace mlir {
 
 class DialectRegistry;
 
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace bufferization_ext {
 
 void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
 
 } // namespace bufferization_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_BUFFERIZATION_INTERFACE_IMPL_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_BUFFERIZATIONINTERFACEIMPL_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.h

 //===- ComprehensiveBufferize.h - Linalg bufferization pass -----*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_COMPREHENSIVE_BUFFERIZE_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_COMPREHENSIVE_BUFFERIZE_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_COMPREHENSIVEBUFFERIZE_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_COMPREHENSIVEBUFFERIZE_H
 
 #include "mlir/IR/BuiltinOps.h"
 
 namespace mlir {
 
 namespace linalg {
 namespace comprehensive_bufferize {
 

 LogicalResult
 runComprehensiveBufferize(Operation *op,
                           std::unique_ptr<BufferizationOptions> options);
 
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_COMPREHENSIVE_BUFFERIZE_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_COMPREHENSIVEBUFFERIZE_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/LinalgInterfaceImpl.h

 //===- LinalgInterfaceImpl.h - Linalg Impl. of BufferizableOpInterface ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_LINALG_INTERFACE_IMPL_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_LINALG_INTERFACE_IMPL_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_LINALGINTERFACEIMPL_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_LINALGINTERFACEIMPL_H
 
 #include "mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h"
 
 namespace mlir {
 
 class DialectRegistry;
 
 namespace linalg {

 
 void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
 
 } // namespace linalg_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_LINALG_INTERFACE_IMPL_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_LINALGINTERFACEIMPL_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ModuleBufferization.h

 //===- ModuleBufferization.h - Bufferization across Func. Boundaries ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_MODULE_BUFFERIZATION_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_MODULE_BUFFERIZATION_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_MODULEBUFFERIZATION_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_MODULEBUFFERIZATION_H
 
 #include <memory>
 
 namespace mlir {
 
 class DialectRegistry;
 struct LogicalResult;
 class ModuleOp;

 
 void registerModuleBufferizationExternalModels(DialectRegistry &registry);
 
 } // namespace std_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_MODULE_BUFFERIZATION_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_MODULEBUFFERIZATION_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/SCFInterfaceImpl.h

 //===- SCFInterfaceImpl.h - SCF Impl. of BufferizableOpInterface ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_SCF_INTERFACE_IMPL_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_SCF_INTERFACE_IMPL_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_SCFINTERFACEIMPL_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_SCFINTERFACEIMPL_H
 
 #include "mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h"
 
 namespace mlir {
 
 class DialectRegistry;
 
 namespace linalg {

 
 void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
 
 } // namespace scf_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_SCF_INTERFACE_IMPL_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_SCFINTERFACEIMPL_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/TensorInterfaceImpl.h

 //===- LinalgInterfaceImpl.h - Linalg Impl. of BufferizableOpInterface ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_TENSOR_INTERFACE_IMPL_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_TENSOR_INTERFACE_IMPL_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_TENSORINTERFACEIMPL_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_TENSORINTERFACEIMPL_H
 
 namespace mlir {
 
 class DialectRegistry;
 
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace tensor_ext {
 
 void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
 
 } // namespace tensor_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_TENSOR_INTERFACE_IMPL_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_TENSORINTERFACEIMPL_H

mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/VectorInterfaceImpl.h

 //===- VectorInterfaceImpl.h - Vector Impl. of BufferizableOpInterface ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_VECTOR_INTERFACE_IMPL_H
-#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_VECTOR_INTERFACE_IMPL_H
+#ifndef MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_VECTORINTERFACEIMPL_H
+#define MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_VECTORINTERFACEIMPL_H
 
 namespace mlir {
 
 class DialectRegistry;
 
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace vector_ext {
 
 void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
 
 } // namespace vector_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_VECTOR_INTERFACE_IMPL_H
+#endif // MLIR_DIALECT_LINALG_COMPREHENSIVEBUFFERIZE_VECTORINTERFACEIMPL_H

mlir/include/mlir/Dialect/Linalg/IR/Linalg.h

 //===- Linalg.h - Linalg dialect --------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_LINALG_H_
-#define MLIR_DIALECT_LINALG_LINALG_H_
+#ifndef MLIR_DIALECT_LINALG_IR_LINALG_H
+#define MLIR_DIALECT_LINALG_IR_LINALG_H
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"

 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.h.inc"
 
-#endif // MLIR_DIALECT_LINALG_LINALG_H_
+#endif // MLIR_DIALECT_LINALG_IR_LINALG_H

mlir/include/mlir/Dialect/Linalg/Transforms/HoistPadding.h

 //===- HoistPadding.h - Hoisting transformation for PadTensorOp -*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_TRANSFORMS_HOIST_PADDING_H_
-#define MLIR_DIALECT_LINALG_TRANSFORMS_HOIST_PADDING_H_
+#ifndef MLIR_DIALECT_LINALG_TRANSFORMS_HOISTPADDING_H
+#define MLIR_DIALECT_LINALG_TRANSFORMS_HOISTPADDING_H
 
 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
 class Value;
 
 namespace linalg {
 class PadTensorOp;

 ///    }
 /// ```
 FailureOr<Value> hoistPaddingOnTensors(PadTensorOp opToHoist, int numLoops,
                                        PadTensorOp &hoistedOp);
 
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_TRANSFORMS_HOIST_PADDING_H_
+#endif // MLIR_DIALECT_LINALG_TRANSFORMS_HOISTPADDING_H

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

 //===- Transforms.h - Linalg transformations as patterns --------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H_
-#define DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H_
+#ifndef MLIR_DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H
+#define MLIR_DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H
 
 #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/Utils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/Dialect/Vector/VectorTransforms.h"
patterns.add<LinalgTilingPattern>(OpTy::getOperationName(),
                                       patterns.getContext(), options, f);
     TilingPatterns<OpTypes...>::insert(patterns, options, f);
   }
 };
 
 } // namespace linalg
 } // namespace mlir
 
-#endif // DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H_
+#endif // MLIR_DIALECT_LINALG_TRANSFORMS_TRANSFORMS_H

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

 //===- Utils.h - Utilities to support the Linalg dialect --------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_UTILS_H_
-#define MLIR_DIALECT_LINALG_UTILS_H_
+#ifndef MLIR_DIALECT_LINALG_UTILS_UTILS_H
+#define MLIR_DIALECT_LINALG_UTILS_UTILS_H
 
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 
static void doit(OpBuilder &b, Location loc, ArrayRef<Range> loopRanges,
                        bodyBuilderFn,
                    Optional<LinalgLoopDistributionOptions> = None,
                    ArrayRef<StringRef> distributionTypes = {});
 };
 
 } // namespace linalg
 } // namespace mlir
 
-#endif // MLIR_DIALECT_LINALG_UTILS_H_
+#endif // MLIR_DIALECT_LINALG_UTILS_UTILS_H

mlir/include/mlir/Dialect/Math/Transforms/Approximation.h

 //===- Approximation.h - Math dialect -----------------------------*- C++-*-==//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_MATH_TRANSFORMATIONS_APPROXIMATION_H_
-#define MLIR_DIALECT_MATH_TRANSFORMATIONS_APPROXIMATION_H_
+#ifndef MLIR_DIALECT_MATH_TRANSFORMS_APPROXIMATION_H
+#define MLIR_DIALECT_MATH_TRANSFORMS_APPROXIMATION_H
 
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 namespace math {
 
 struct ErfPolynomialApproximation : public OpRewritePattern<math::ErfOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(math::ErfOp op,
                                 PatternRewriter &rewriter) const final;
 };
 
 } // namespace math
 } // namespace mlir
 
-#endif // MLIR_DIALECT_MATH_TRANSFORMATIONS_APPROXIMATION_H_
+#endif // MLIR_DIALECT_MATH_TRANSFORMS_APPROXIMATION_H

mlir/include/mlir/Dialect/Quant/QuantTypes.h

 //===- QuantTypes.h - Quantization Ops and Types ----------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_QUANT_QUANT_TYPES_H_
-#define MLIR_DIALECT_QUANT_QUANT_TYPES_H_
+#ifndef MLIR_DIALECT_QUANT_QUANTTYPES_H
+#define MLIR_DIALECT_QUANT_QUANTTYPES_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/Types.h"
 #include "llvm/Support/MathExtras.h"
static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
                               Type expressedType, double min, double max);
   double getMin() const;
   double getMax() const;
 };
 
 } // namespace quant
 } // namespace mlir
 
-#endif // MLIR_DIALECT_QUANT_QUANT_TYPES_H_
+#endif // MLIR_DIALECT_QUANT_QUANTTYPES_H

mlir/include/mlir/Dialect/SCF/SCF.h

 //===- SCFOps.h - Structured Control Flow -----------------------*- C++ -*-===//
 //
 // 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 defines structured control flow operations.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SCF_H_
-#define MLIR_DIALECT_SCF_H_
+#ifndef MLIR_DIALECT_SCF_SCF_H
+#define MLIR_DIALECT_SCF_SCF_H
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"

 /// The built nested scf::For are captured in `capturedLoops` when non-null.
 LoopNest buildLoopNest(OpBuilder &builder, Location loc, ValueRange lbs,
                        ValueRange ubs, ValueRange steps,
                        function_ref<void(OpBuilder &, Location, ValueRange)>
                            bodyBuilder = nullptr);
 
 } // namespace scf
 } // namespace mlir
-#endif // MLIR_DIALECT_SCF_H_
+#endif // MLIR_DIALECT_SCF_SCF_H

mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h

 //===- SPIRVConversion.h - SPIR-V Conversion Utilities ----------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines utilities to use while converting to the SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H
-#define MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H
+#ifndef MLIR_DIALECT_SPIRV_TRANSFORMS_SPIRVCONVERSION_H
+#define MLIR_DIALECT_SPIRV_TRANSFORMS_SPIRVCONVERSION_H
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/SmallSet.h"
 
 namespace mlir {

 spirv::AccessChainOp getElementPtr(SPIRVTypeConverter &typeConverter,
                                    MemRefType baseType, Value basePtr,
                                    ValueRange indices, Location loc,
                                    OpBuilder &builder);
 
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H
+#endif // MLIR_DIALECT_SPIRV_TRANSFORMS_SPIRVCONVERSION_H

mlir/include/mlir/Dialect/Shape/IR/Shape.h

 //===- Shape.h - MLIR Shape dialect -----------------------------*- C++ -*-===//
 //
 // 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 defines the shape dialect that is used to describe and solve shape
 // relations of MLIR operations using ShapedType.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_SHAPE_IR_SHAPE_H
-#define MLIR_SHAPE_IR_SHAPE_H
+#ifndef MLIR_DIALECT_SHAPE_IR_SHAPE_H
+#define MLIR_DIALECT_SHAPE_IR_SHAPE_H
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"

 } // namespace shape
 } // namespace mlir
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Shape/IR/ShapeOps.h.inc"
 
 #include "mlir/Dialect/Shape/IR/ShapeOpsDialect.h.inc"
 
-#endif // MLIR_SHAPE_IR_SHAPE_H
+#endif // MLIR_DIALECT_SHAPE_IR_SHAPE_H

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 class PatternRewriter;
 } // namespace mlir
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/StandardOps/IR/Ops.h.inc"
 
 #include "mlir/Dialect/StandardOps/IR/OpsDialect.h.inc"
 
-#endif // MLIR_DIALECT_IR_STANDARDOPS_IR_OPS_H
+#endif // MLIR_DIALECT_STANDARDOPS_IR_OPS_H

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.h

 //===- Passes.h - Pass Entrypoints ------------------------------*- C++ -*-===//
 //
 // 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 header file defines prototypes that expose pass constructors in the loop
 // transformation library.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_
-#define MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_
+#ifndef MLIR_DIALECT_STANDARDOPS_TRANSFORMS_PASSES_H
+#define MLIR_DIALECT_STANDARDOPS_TRANSFORMS_PASSES_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
 } // namespace bufferization
 

 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/StandardOps/Transforms/Passes.h.inc"
 
 } // namespace mlir
 
-#endif // MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_
+#endif // MLIR_DIALECT_STANDARDOPS_TRANSFORMS_PASSES_H

mlir/include/mlir/Dialect/Tosa/Utils/QuantUtils.h

 //===-- QuantUtils.h - TOSA numerical support declarations ------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Function declarations for TOSA numerical support functions and quantization
 // attribute builders
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef DIALECT_TOSA_UTILS_QUANT_UTILS_H
-#define DIALECT_TOSA_UTILS_QUANT_UTILS_H
+#ifndef MLIR_DIALECT_TOSA_UTILS_QUANTUTILS_H
+#define MLIR_DIALECT_TOSA_UTILS_QUANTUTILS_H
 
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 
 #include "mlir/Dialect/Quant/FakeQuantSupport.h"
 #include "mlir/Dialect/Quant/UniformSupport.h"
 
 namespace mlir {
 namespace tosa {

 TypeAttr buildQTypeAttrFromMinMax(OpBuilder builder, Type inputDType,
                                   Attribute minAttr, Attribute maxAttr,
                                   IntegerAttr quantBits, int filterQuantDim,
                                   bool isSigned, BoolAttr narrowRange);
 
 } // namespace tosa
 } // namespace mlir
 
-#endif // DIALECT_TOSA_UTILS_QUANT_UTILS_H
+#endif // MLIR_DIALECT_TOSA_UTILS_QUANTUTILS_H

mlir/include/mlir/Dialect/Traits.h

 //===- Traits.h - Common op traits shared by dialects -----------*- C++ -*-===//
 //
 // 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 declares common op traits that are not core to MLIR but can be
 // shared by multiple dialects.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_TRAITS
-#define MLIR_DIALECT_TRAITS
+#ifndef MLIR_DIALECT_TRAITS_H
+#define MLIR_DIALECT_TRAITS_H
 
 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 namespace OpTrait {
 
 // These functions are out-of-line implementations of the methods in the
 // corresponding trait classes.  This avoids them being template
public:
   static LogicalResult verifyTrait(Operation *op) {
     return impl::verifyCompatibleOperandBroadcast(op);
   }
 };
 
 } // namespace OpTrait
 } // namespace mlir
 
-#endif // MLIR_DIALECT_TRAITS
+#endif // MLIR_DIALECT_TRAITS_H

mlir/include/mlir/Dialect/Utils/StructuredOpsUtils.h

protected:
   Location loc;
   ArrayAttr iterators;
   SmallVector<AffineMap, 4> maps;
   Operation *op;
 };
 
 } // namespace mlir
 
-#endif // MLIR_UTILS_STRUCTUREDOPSUTILS_H
+#endif // MLIR_DIALECT_UTILS_STRUCTUREDOPSUTILS_H

mlir/include/mlir/Dialect/Vector/VectorRewritePatterns.h

 //===- VectorRewritePatterns.h - Vector rewrite patterns --------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef DIALECT_VECTOR_VECTORREWRITEPATTERNS_H_
-#define DIALECT_VECTOR_VECTORREWRITEPATTERNS_H_
+#ifndef MLIR_DIALECT_VECTOR_VECTORREWRITEPATTERNS_H
+#define MLIR_DIALECT_VECTOR_VECTORREWRITEPATTERNS_H
 
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class RewritePatternSet;
private:
   // Lower one reduction dimension.
   Value lowerReduction(vector::ContractionOp op,
                        PatternRewriter &rewriter) const;
 };
 
 } // namespace vector
 } // namespace mlir
 
-#endif // DIALECT_VECTOR_VECTORREWRITEPATTERNS_H_
+#endif // MLIR_DIALECT_VECTOR_VECTORREWRITEPATTERNS_H

mlir/include/mlir/Dialect/Vector/VectorTransforms.h

 //===- VectorTransforms.h - Vector transformations as patterns --*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef DIALECT_VECTOR_VECTORTRANSFORMS_H_
-#define DIALECT_VECTOR_VECTORTRANSFORMS_H_
+#ifndef MLIR_DIALECT_VECTOR_VECTORTRANSFORMS_H
+#define MLIR_DIALECT_VECTOR_VECTORTRANSFORMS_H
 
 #include "mlir/Dialect/Vector/VectorRewritePatterns.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 
 namespace mlir {
 class MLIRContext;
 class VectorTransferOpInterface;
 class RewritePatternSet;

 
 /// Implements transfer op write to read forwarding and dead transfer write
 /// optimizations.
 void transferOpflowOpt(FuncOp func);
 
 } // namespace vector
 } // namespace mlir
 
-#endif // DIALECT_VECTOR_VECTORTRANSFORMS_H_
+#endif // MLIR_DIALECT_VECTOR_VECTORTRANSFORMS_H

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

 //===- CRunnerUtils.h - Utils for debugging MLIR execution ----------------===//
 //
 // 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 declares basic classes and functions to manipulate structured MLIR
 // types at runtime. Entities in this file must be compliant with C++11 and be
 // retargetable, including on targets without a C++ runtime.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef EXECUTIONENGINE_CRUNNERUTILS_H_
-#define EXECUTIONENGINE_CRUNNERUTILS_H_
+#ifndef MLIR_EXECUTIONENGINE_CRUNNERUTILS_H
+#define MLIR_EXECUTIONENGINE_CRUNNERUTILS_H
 
 #ifdef _WIN32
 #ifndef MLIR_CRUNNERUTILS_EXPORT
 #ifdef mlir_c_runner_utils_EXPORTS
 // We are building this library
 #define MLIR_CRUNNERUTILS_EXPORT __declspec(dllexport)
 #define MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS
 #else

 extern "C" MLIR_CRUNNERUTILS_EXPORT void printNewline();
 
 //===----------------------------------------------------------------------===//
 // Small runtime support library for timing execution and printing GFLOPS
 //===----------------------------------------------------------------------===//
 extern "C" MLIR_CRUNNERUTILS_EXPORT void print_flops(double flops);
 extern "C" MLIR_CRUNNERUTILS_EXPORT double rtclock();
 
-#endif // EXECUTIONENGINE_CRUNNERUTILS_H_
+#endif // MLIR_EXECUTIONENGINE_CRUNNERUTILS_H

mlir/include/mlir/ExecutionEngine/JitRunner.h

 // utilities that execute an MLIR file on the CPU by translating MLIR to LLVM
 // IR before JIT-compiling and executing the latter.
 //
 // The translation can be customized by providing an MLIR to MLIR
 // transformation.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_SUPPORT_JITRUNNER_H_
-#define MLIR_SUPPORT_JITRUNNER_H_
+#ifndef MLIR_EXECUTIONENGINE_JITRUNNER_H
+#define MLIR_EXECUTIONENGINE_JITRUNNER_H
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
 
 namespace llvm {
 class Module;
 class LLVMContext;
 

 /// standard C++ main functions. The supplied dialect registry is expected to
 /// contain any registers that appear in the input IR, they will be loaded
 /// on-demand by the parser.
 int JitRunnerMain(int argc, char **argv, const DialectRegistry &registry,
                   JitRunnerConfig config = {});
 
 } // namespace mlir
 
-#endif // MLIR_SUPPORT_JITRUNNER_H_
+#endif // MLIR_EXECUTIONENGINE_JITRUNNER_H

mlir/include/mlir/ExecutionEngine/OptUtils.h

 //===- OptUtils.h - MLIR Execution Engine opt pass utilities ----*- C++ -*-===//
 //
 // 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 declares the utility functions to trigger LLVM optimizations from
 // MLIR Execution Engine.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_EXECUTIONENGINE_OPTUTILS_H_
-#define MLIR_EXECUTIONENGINE_OPTUTILS_H_
+#ifndef MLIR_EXECUTIONENGINE_OPTUTILS_H
+#define MLIR_EXECUTIONENGINE_OPTUTILS_H
 
 #include "llvm/Pass.h"
 
 #include <functional>
 #include <string>
 
 namespace llvm {
 class Module;

 std::function<llvm::Error(llvm::Module *)>
 makeLLVMPassesTransformer(llvm::ArrayRef<const llvm::PassInfo *> llvmPasses,
                           llvm::Optional<unsigned> mbOptLevel,
                           llvm::TargetMachine *targetMachine,
                           unsigned optPassesInsertPos = 0);
 
 } // namespace mlir
 
-#endif // LIR_EXECUTIONENGINE_OPTUTILS_H_
+#endif // MLIR_EXECUTIONENGINE_OPTUTILS_H

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

 //===- RunnerUtils.h - Utils for debugging MLIR execution -----------------===//
 //
 // 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 declares basic classes and functions to debug structured MLIR
 // types at runtime. Entities in this file may not be compatible with targets
 // without a C++ runtime. These may be progressively migrated to CRunnerUtils.h
 // over time.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef EXECUTIONENGINE_RUNNERUTILS_H_
-#define EXECUTIONENGINE_RUNNERUTILS_H_
+#ifndef MLIR_EXECUTIONENGINE_RUNNERUTILS_H
+#define MLIR_EXECUTIONENGINE_RUNNERUTILS_H
 
 #ifdef _WIN32
 #ifndef MLIR_RUNNERUTILS_EXPORT
 #ifdef mlir_runner_utils_EXPORTS
 // We are building this library
 #define MLIR_RUNNERUTILS_EXPORT __declspec(dllexport)
 #else
 // We are using this library
extern "C" MLIR_RUNNERUTILS_EXPORT int64_t verifyMemRefI32(int64_t rank,
                                                            void *expectedPtr);
 extern "C" MLIR_RUNNERUTILS_EXPORT int64_t verifyMemRefF32(int64_t rank,
                                                            void *actualPtr,
                                                            void *expectedPtr);
 extern "C" MLIR_RUNNERUTILS_EXPORT int64_t verifyMemRefF64(int64_t rank,
                                                            void *actualPtr,
                                                            void *expectedPtr);
 
-#endif // EXECUTIONENGINE_RUNNERUTILS_H_
+#endif // MLIR_EXECUTIONENGINE_RUNNERUTILS_H

mlir/include/mlir/IR/AffineExpr.h

 //===- AffineExpr.h - MLIR Affine Expr Class --------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // An affine expression is an affine combination of dimension identifiers and
 // symbols, including ceildiv/floordiv/mod by a constant integer.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_AFFINE_EXPR_H
-#define MLIR_IR_AFFINE_EXPR_H
+#ifndef MLIR_IR_AFFINEEXPR_H
+#define MLIR_IR_AFFINEEXPR_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Support/Casting.h"
 #include <functional>
 #include <type_traits>
 
struct DenseMapInfo<mlir::AffineExpr> {
   }
   static bool isEqual(mlir::AffineExpr LHS, mlir::AffineExpr RHS) {
     return LHS == RHS;
   }
 };
 
 } // namespace llvm
 
-#endif // MLIR_IR_AFFINE_EXPR_H
+#endif // MLIR_IR_AFFINEEXPR_H

mlir/include/mlir/IR/AffineExprVisitor.h

 //===- AffineExprVisitor.h - MLIR AffineExpr Visitor Class ------*- C++ -*-===//
 //
 // 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 defines the AffineExpr visitor class.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_AFFINE_EXPR_VISITOR_H
-#define MLIR_IR_AFFINE_EXPR_VISITOR_H
+#ifndef MLIR_IR_AFFINEEXPRVISITOR_H
+#define MLIR_IR_AFFINEEXPRVISITOR_H
 
 #include "mlir/IR/AffineExpr.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mlir {
 
 /// Base class for AffineExpr visitors/walkers.
 ///
private:
   inline unsigned getConstantIndex() const { return getNumCols() - 1; }
   inline unsigned getLocalVarStartIndex() const { return numDims + numSymbols; }
   inline unsigned getSymbolStartIndex() const { return numDims; }
   inline unsigned getDimStartIndex() const { return 0; }
 };
 
 } // namespace mlir
 
-#endif // MLIR_IR_AFFINE_EXPR_VISITOR_H
+#endif // MLIR_IR_AFFINEEXPRVISITOR_H

mlir/include/mlir/IR/AffineMap.h

 //===- AffineMap.h - MLIR Affine Map Class ----------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Affine maps are mathematical functions which map a list of dimension
 // identifiers and symbols, to multidimensional affine expressions.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_AFFINE_MAP_H
-#define MLIR_IR_AFFINE_MAP_H
+#ifndef MLIR_IR_AFFINEMAP_H
+#define MLIR_IR_AFFINEMAP_H
 
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace mlir {
struct DenseMapInfo<mlir::AffineMap> {
   }
   static bool isEqual(mlir::AffineMap LHS, mlir::AffineMap RHS) {
     return LHS == RHS;
   }
 };
 
 } // namespace llvm
 
-#endif // MLIR_IR_AFFINE_MAP_H
+#endif // MLIR_IR_AFFINEMAP_H

mlir/include/mlir/IR/BlockSupport.h

 //===- BlockSupport.h -------------------------------------------*- C++ -*-===//
 //
 // 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 defines a number of support types for the Block class.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_BLOCK_SUPPORT_H
-#define MLIR_IR_BLOCK_SUPPORT_H
+#ifndef MLIR_IR_BLOCKSUPPORT_H
+#define MLIR_IR_BLOCKSUPPORT_H
 
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 
 namespace mlir {
 class Block;
void transferNodesFromList(ilist_traits<Block> &otherList,
                              block_iterator first, block_iterator last);
 
 private:
   mlir::Region *getParentRegion();
 };
 
 } // namespace llvm
 
-#endif // MLIR_IR_BLOCK_SUPPORT_H
+#endif // MLIR_IR_BLOCKSUPPORT_H

mlir/include/mlir/IR/IntegerSet.h

 // inequalities are themselves unique.
 
 // This class is not meant for affine analysis and operations like set
 // operations, emptiness checks, or other math operations for analysis and
 // transformation. For the latter, use FlatAffineConstraints.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_INTEGER_SET_H
-#define MLIR_IR_INTEGER_SET_H
+#ifndef MLIR_IR_INTEGERSET_H
+#define MLIR_IR_INTEGERSET_H
 
 #include "mlir/IR/AffineExpr.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mlir {
 
 namespace detail {
 struct IntegerSetStorage;
static unsigned getHashValue(mlir::IntegerSet val) {
     return mlir::hash_value(val);
   }
   static bool isEqual(mlir::IntegerSet LHS, mlir::IntegerSet RHS) {
     return LHS == RHS;
   }
 };
 
 } // namespace llvm
-#endif // MLIR_IR_INTEGER_SET_H
+#endif // MLIR_IR_INTEGERSET_H

mlir/include/mlir/IR/Matchers.h

 //===- Matchers.h - Various common matchers ---------------------*- C++ -*-===//
 //
 // 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 provides a simple and efficient mechanism for performing general
 // tree-based pattern matching over MLIR. This mechanism is inspired by LLVM's
 // include/llvm/IR/PatternMatch.h.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_MATCHERS_H
-#define MLIR_MATCHERS_H
+#ifndef MLIR_IR_MATCHERS_H
+#define MLIR_IR_MATCHERS_H
 
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 
 namespace detail {
 

 namespace matchers {
 inline auto m_Any() { return detail::AnyValueMatcher(); }
 inline auto m_Any(Value *val) { return detail::AnyCapturedValueMatcher(val); }
 inline auto m_Val(Value v) { return detail::PatternMatcherValue(v); }
 } // namespace matchers
 
 } // namespace mlir
 
-#endif // MLIR_MATCHERS_H
+#endif // MLIR_IR_MATCHERS_H

mlir/include/mlir/IR/OperationSupport.h

 //===- OperationSupport.h ---------------------------------------*- C++ -*-===//
 //
 // 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 defines a number of support types that Operation and related
 // classes build on top of.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_OPERATION_SUPPORT_H
-#define MLIR_IR_OPERATION_SUPPORT_H
+#ifndef MLIR_IR_OPERATIONSUPPORT_H
+#define MLIR_IR_OPERATIONSUPPORT_H
 
 #include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Support/InterfaceSupport.h"

mlir/include/mlir/IR/PatternMatch.h

 //===- PatternMatch.h - PatternMatcher classes -------==---------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_PATTERNMATCHER_H
-#define MLIR_PATTERNMATCHER_H
+#ifndef MLIR_IR_PATTERNMATCH_H
+#define MLIR_IR_PATTERNMATCH_H
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/Support/TypeName.h"
 
 namespace mlir {
 
private:
 
   MLIRContext *const context;
   NativePatternListT nativePatterns;
   PDLPatternModule pdlPatterns;
 };
 
 } // namespace mlir
 
-#endif // MLIR_PATTERN_MATCH_H
+#endif // MLIR_IR_PATTERNMATCH_H

mlir/include/mlir/IR/SubElementInterfaces.h

 //===- SubElementInterfaces.h - Attr and Type SubElements -------*- C++ -*-===//
 //
 // 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 contains interfaces and utilities for querying the sub elements of
 // an attribute or type.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_INTERFACES_SUBELEMENTINTERFACES_H
-#define MLIR_INTERFACES_SUBELEMENTINTERFACES_H
+#ifndef MLIR_IR_SUBELEMENTINTERFACES_H
+#define MLIR_IR_SUBELEMENTINTERFACES_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Types.h"
 
 /// Include the definitions of the sub elemnt interfaces.
 #include "mlir/IR/SubElementAttrInterfaces.h.inc"
 #include "mlir/IR/SubElementTypeInterfaces.h.inc"
 
-#endif // MLIR_INTERFACES_SUBELEMENTINTERFACES_H
+#endif // MLIR_IR_SUBELEMENTINTERFACES_H

mlir/include/mlir/IR/TypeSupport.h

 //===- TypeSupport.h --------------------------------------------*- C++ -*-===//
 //
 // 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 defines support types for registering dialect extended types.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_TYPE_SUPPORT_H
-#define MLIR_IR_TYPE_SUPPORT_H
+#ifndef MLIR_IR_TYPESUPPORT_H
+#define MLIR_IR_TYPESUPPORT_H
 
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StorageUniquerSupport.h"
 #include "llvm/ADT/Twine.h"
 
 namespace mlir {
 class Dialect;
 class MLIRContext;

mlir/include/mlir/IR/TypeUtilities.h

 //===- TypeUtilities.h - Helper function for type queries -------*- C++ -*-===//
 //
 // 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 defines generic type utilities.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_SUPPORT_TYPEUTILITIES_H
-#define MLIR_SUPPORT_TYPEUTILITIES_H
+#ifndef MLIR_IR_TYPEUTILITIES_H
+#define MLIR_IR_TYPEUTILITIES_H
 
 #include "mlir/IR/Operation.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace mlir {
 
 class Attribute;
 class TupleType;
public:
   /// Map the element to the iterator result type.
   Type mapElement(Value value) const;
 };
 
 using ResultElementTypeRange = iterator_range<ResultElementTypeIterator>;
 
 } // namespace mlir
 
-#endif // MLIR_SUPPORT_TYPEUTILITIES_H
+#endif // MLIR_IR_TYPEUTILITIES_H

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

 //===- SideEffectInterfaces.h - SideEffect in MLIR --------------*- C++ -*-===//
 //
 // 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 contains traits, interfaces, and utilities for defining and
 // querying the side effects of an operation.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_INTERFACES_SIDEEFFECTS_H
-#define MLIR_INTERFACES_SIDEEFFECTS_H
+#ifndef MLIR_INTERFACES_SIDEEFFECTINTERFACES_H
+#define MLIR_INTERFACES_SIDEEFFECTINTERFACES_H
 
 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 namespace SideEffects {
 //===----------------------------------------------------------------------===//
 // Effects
 //===----------------------------------------------------------------------===//

 
 //===----------------------------------------------------------------------===//
 // SideEffect Interfaces
 //===----------------------------------------------------------------------===//
 
 /// Include the definitions of the side effect interfaces.
 #include "mlir/Interfaces/SideEffectInterfaces.h.inc"
 
-#endif // MLIR_INTERFACES_SIDEEFFECTS_H
+#endif // MLIR_INTERFACES_SIDEEFFECTINTERFACES_H

mlir/include/mlir/Support/DebugStringHelper.h

 //===- DebugStringHelper.h - helpers to generate debug strings --*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Convenience functions to make it easier to get a string representation for
 // ops that have a print method. For use in debugging output and errors
 // returned.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DEBUGSTRINGHELPER_H_
-#define MLIR_DEBUGSTRINGHELPER_H_
+#ifndef MLIR_SUPPORT_DEBUGSTRINGHELPER_H
+#define MLIR_SUPPORT_DEBUGSTRINGHELPER_H
 
 #include <string>
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_os_ostream.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {

 } // namespace mlir
 
 inline std::ostream &operator<<(std::ostream &out, const llvm::Twine &twine) {
   llvm::raw_os_ostream rout(out);
   rout << twine;
   return out;
 }
 
-#endif // MLIR_DEBUGSTRINGHELPER_H_
+#endif // MLIR_SUPPORT_DEBUGSTRINGHELPER_H

mlir/include/mlir/Support/LogicalResult.h

 //===- LogicalResult.h - Utilities for handling success/failure -*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_SUPPORT_LOGICAL_RESULT_H
-#define MLIR_SUPPORT_LOGICAL_RESULT_H
+#ifndef MLIR_SUPPORT_LOGICALRESULT_H
+#define MLIR_SUPPORT_LOGICALRESULT_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/Optional.h"
 
 namespace mlir {
 
 /// This class represents an efficient way to signal success or failure. It
 /// should be preferred over the use of `bool` when appropriate, as it avoids

 private:
   /// Hide the bool conversion as it easily creates confusion.
   using Optional<T>::operator bool;
   using Optional<T>::hasValue;
 };
 
 } // namespace mlir
 
-#endif // MLIR_SUPPORT_LOGICAL_RESULT_H
+#endif // MLIR_SUPPORT_LOGICALRESULT_H

mlir/include/mlir/Target/SPIRV/SPIRVBinaryUtils.h

 //===- SPIRVBinaryUtils.cpp - SPIR-V Binary Module Utils --------*- C++ -*-===//
 //
 // 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 declares common utilities for SPIR-V binary module.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TARGET_SPIRV_BINARY_UTILS_H_
-#define MLIR_TARGET_SPIRV_BINARY_UTILS_H_
+#ifndef MLIR_TARGET_SPIRV_SPIRVBINARYUTILS_H
+#define MLIR_TARGET_SPIRV_SPIRVBINARYUTILS_H
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
 #include "mlir/Support/LLVM.h"
 
 #include <cstdint>
 
 namespace mlir {
 namespace spirv {
inline StringRef decodeStringLiteral(ArrayRef<uint32_t> words,
   StringRef str(reinterpret_cast<const char *>(words.data() + wordIndex));
   wordIndex += str.size() / 4 + 1;
   return str;
 }
 
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_TARGET_SPIRV_BINARY_UTILS_H_
+#endif // MLIR_TARGET_SPIRV_SPIRVBINARYUTILS_H

mlir/include/mlir/Tools/PDLL/AST/Diagnostic.h

 //===- Diagnostic.h - PDLL AST Diagnostics ----------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TOOLS_PDLL_AST_DIAGNOSTICS_H_
-#define MLIR_TOOLS_PDLL_AST_DIAGNOSTICS_H_
+#ifndef MLIR_TOOLS_PDLL_AST_DIAGNOSTIC_H
+#define MLIR_TOOLS_PDLL_AST_DIAGNOSTIC_H
 
 #include <string>
 
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/Support/SourceMgr.h"
 
private:
   /// The registered diagnostic handler function.
   HandlerFn handler;
 };
 
 } // namespace ast
 } // namespace pdll
 } // namespace mlir
 
-#endif // MLIR_TOOLS_PDLL_AST_DIAGNOSTICS_H_
+#endif // MLIR_TOOLS_PDLL_AST_DIAGNOSTIC_H

mlir/include/mlir/Tools/mlir-lsp-server/MlirLspServerMain.h

 //===- MlirLspServerMain.h - MLIR Language Server main ----------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for mlir-lsp-server for when built as standalone binary.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TOOLS_MLIRLSPSERVER_MLIRLSPSERVERMAIN_H
-#define MLIR_TOOLS_MLIRLSPSERVER_MLIRLSPSERVERMAIN_H
+#ifndef MLIR_TOOLS_MLIR_LSP_SERVER_MLIRLSPSERVERMAIN_H
+#define MLIR_TOOLS_MLIR_LSP_SERVER_MLIRLSPSERVERMAIN_H
 
 namespace mlir {
 class DialectRegistry;
 struct LogicalResult;
 
 /// Implementation for tools like `mlir-lsp-server`.
 /// - registry should contain all the dialects that can be parsed in source IR
 /// passed to the server.
 LogicalResult MlirLspServerMain(int argc, char **argv,
                                 DialectRegistry &registry);
 
 } // namespace mlir
 
-#endif // MLIR_TOOLS_MLIRLSPSERVER_MLIRLSPSERVERMAIN_H
+#endif // MLIR_TOOLS_MLIR_LSP_SERVER_MLIRLSPSERVERMAIN_H

mlir/include/mlir/Tools/mlir-reduce/MlirReduceMain.h

 //===- MlirReduceMain.h - MLIR Reducer driver -------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TOOLS_MLIRREDUCE_MLIRREDUCEMAIN_H
-#define MLIR_TOOLS_MLIRREDUCE_MLIRREDUCEMAIN_H
+#ifndef MLIR_TOOLS_MLIR_REDUCE_MLIRREDUCEMAIN_H
+#define MLIR_TOOLS_MLIR_REDUCE_MLIRREDUCEMAIN_H
 
 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
 
 class MLIRContext;
 
 LogicalResult mlirReduceMain(int argc, char **argv, MLIRContext &context);
 
 } // namespace mlir
 
-#endif // MLIR_TOOLS_MLIRREDUCE_MLIRREDUCEMAIN_H
+#endif // MLIR_TOOLS_MLIR_REDUCE_MLIRREDUCEMAIN_H

mlir/include/mlir/Transforms/InliningUtils.h

 //===- InliningUtils.h - Inliner utilities ----------------------*- C++ -*-===//
 //
 // 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 header file defines interfaces for various inlining utility methods.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TRANSFORMS_INLINING_UTILS_H
-#define MLIR_TRANSFORMS_INLINING_UTILS_H
+#ifndef MLIR_TRANSFORMS_INLININGUTILS_H
+#define MLIR_TRANSFORMS_INLININGUTILS_H
 
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Region.h"
 
 namespace mlir {
 
 class Block;

 /// corresponds to whether the source region should be cloned into the 'call' or
 /// spliced directly.
 LogicalResult inlineCall(InlinerInterface &interface, CallOpInterface call,
                          CallableOpInterface callable, Region *src,
                          bool shouldCloneInlinedRegion = true);
 
 } // namespace mlir
 
-#endif // MLIR_TRANSFORMS_INLINING_UTILS_H
+#endif // MLIR_TRANSFORMS_INLININGUTILS_H

mlir/include/mlir/Transforms/LoopFusionUtils.h

 //===- LoopFusionUtils.h - Loop fusion utilities ----------------*- C++ -*-===//
 //
 // 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 header file defines prototypes for various loop fusion utility
 // methods: these are not passes by themselves but are used either by passes,
 // optimization sequences, or in turn by other transformation utilities.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TRANSFORMS_LOOP_FUSION_UTILS_H
-#define MLIR_TRANSFORMS_LOOP_FUSION_UTILS_H
+#ifndef MLIR_TRANSFORMS_LOOPFUSIONUTILS_H
+#define MLIR_TRANSFORMS_LOOPFUSIONUTILS_H
 
 #include "mlir/IR/Value.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {
 class AffineForOp;

 /// Returns in 'producerConsumerMemrefs' the memrefs involved in a
 /// producer-consumer dependence between write ops in 'srcOps' and read ops in
 /// 'dstOps'.
 void gatherProducerConsumerMemrefs(ArrayRef<Operation *> srcOps,
                                    ArrayRef<Operation *> dstOps,
                                    DenseSet<Value> &producerConsumerMemrefs);
 } // namespace mlir
 
-#endif // MLIR_TRANSFORMS_LOOP_FUSION_UTILS_H
+#endif // MLIR_TRANSFORMS_LOOPFUSIONUTILS_H

mlir/include/mlir/Transforms/LoopUtils.h

 //===- LoopUtils.h - Loop transformation utilities --------------*- C++ -*-===//
 //
 // 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 header file defines prototypes for various loop transformation utility
 // methods: these are not passes by themselves but are used either by passes,
 // optimization sequences, or in turn by other transformation utilities.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TRANSFORMS_LOOP_UTILS_H
-#define MLIR_TRANSFORMS_LOOP_UTILS_H
+#ifndef MLIR_TRANSFORMS_LOOPUTILS_H
+#define MLIR_TRANSFORMS_LOOPUTILS_H
 
 #include "mlir/IR/Block.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
 class AffineForOp;
 class AffineMap;

 separateFullTiles(MutableArrayRef<AffineForOp> nest,
                   SmallVectorImpl<AffineForOp> *fullTileNest = nullptr);
 
 /// Move loop invariant code out of `looplike`.
 LogicalResult moveLoopInvariantCode(LoopLikeOpInterface looplike);
 
 } // namespace mlir
 
-#endif // MLIR_TRANSFORMS_LOOP_UTILS_H
+#endif // MLIR_TRANSFORMS_LOOPUTILS_H