[NFC] Inclusive language: Remove instances of master in URLs

[quinnp]

Summary

[NFC] This patch fixes URLs containing "master". Old URLs were either broken or
redirecting to the new URL.

clang-tools-extra/clangd/Protocol.h

 //===--- Protocol.h - Language Server Protocol Implementation ---*- 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 structs based on the LSP specification at
-// https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md
+// https://github.com/Microsoft/language-server-protocol/blob/main/protocol.md
 //
 // This is not meant to be a complete implementation, new interfaces are added
 // when they're needed.
 //
 // Each struct has a toJSON and fromJSON function, that converts between
 // the struct and a JSON representation. (See JSON.h)
 //
 // Some structs also have operator<< serialization. This is for debugging and
enum class InsertTextFormat {
   /// The primary text to be inserted is treated as a snippet.
   ///
   /// A snippet can define tab stops and placeholders with `$1`, `$2`
   /// and `${3:foo}`. `$0` defines the final tab stop, it defaults to the end
   /// of the snippet. Placeholders with equal identifiers are linked, that is
   /// typing in one will update others too.
   ///
   /// See also:
-  /// https//github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md
+  /// https://github.com/Microsoft/vscode/blob/main/src/vs/editor/contrib/snippet/snippet.md
   Snippet = 2,
 };
 
 struct CompletionItem {
   /// The label of this completion item. By default also the text that is
   /// inserted when selecting this completion.
   std::string label;
 

clang/docs/ClangFormatStyleOptions.rst

**BasedOnStyle** (``String``)
   * ``LLVM``
     A style complying with the `LLVM coding standards
     <https://llvm.org/docs/CodingStandards.html>`_
   * ``Google``
     A style complying with `Google's C++ style guide
     <https://google.github.io/styleguide/cppguide.html>`_
   * ``Chromium``
     A style complying with `Chromium's style guide
-    <https://chromium.googlesource.com/chromium/src/+/master/styleguide/styleguide.md>`_
+    <https://chromium.googlesource.com/chromium/src/+/refs/heads/main/styleguide/styleguide.md>`_
   * ``Mozilla``
     A style complying with `Mozilla's style guide
     <https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style>`_
   * ``WebKit``
     A style complying with `WebKit's style guide
     <https://www.webkit.org/coding/coding-style.html>`_
   * ``Microsoft``
     A style complying with `Microsoft's style guide

clang/docs/LibFormat.rst

.. code-block:: c++
   /// https://llvm.org/docs/CodingStandards.html.
   FormatStyle getLLVMStyle();
 
   /// Returns a format style complying with Google's C++ style guide:
   /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
   FormatStyle getGoogleStyle();
 
   /// Returns a format style complying with Chromium's style guide:
-  /// https://chromium.googlesource.com/chromium/src/+/master/styleguide/styleguide.md
+  /// https://chromium.googlesource.com/chromium/src/+/refs/heads/main/styleguide/styleguide.md
   FormatStyle getChromiumStyle();
 
   /// Returns a format style complying with the GNU coding standards:
   /// https://www.gnu.org/prep/standards/standards.html
   FormatStyle getGNUStyle();
 
   /// Returns a format style complying with Mozilla's style guide
   /// https://firefox-source-docs.mozilla.org/code-quality/coding-style/index.html

clang/docs/UsersManual.rst

 
 There is no conflict resolution for identifier clashes among extensions.
 It is therefore recommended that the identifiers are prefixed with a
 double underscore to avoid clashing with user space identifiers. Vendor
 extension should use reserved identifier prefix e.g. amd, arm, intel.
 
 Clang also supports language extensions documented in `The OpenCL C Language
 Extensions Documentation
-<https://github.com/KhronosGroup/Khronosdotorg/blob/master/api/opencl/assets/OpenCL_LangExt.pdf>`_.
+<https://github.com/KhronosGroup/Khronosdotorg/blob/main/api/opencl/assets/OpenCL_LangExt.pdf>`_.
 
 OpenCL-Specific Attributes
 --------------------------
 
 OpenCL support in Clang contains a set of attribute taken directly from the
 specification as well as additional attributes.
 
 See also :doc:`AttributeReference`.

clang/lib/AST/ItaniumMangle.cpp

 //   "9__SVE_VLSI" + base type mangling + "Lj" + __ARM_FEATURE_SVE_BITS + "EE"
 //
 //   i.e. 9__SVE_VLSIu11__SVInt32_tLj512EE
 //
 // The latest ACLE specification (00bet5) does not contain details of this
 // mangling scheme, it will be specified in the next revision. The mangling
 // scheme is otherwise defined in the appendices to the Procedure Call Standard
 // for the Arm Architecture, see
-// https://github.com/ARM-software/abi-aa/blob/master/aapcs64/aapcs64.rst#appendix-c-mangling
+// https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst#appendix-c-mangling
 void CXXNameMangler::mangleAArch64FixedSveVectorType(const VectorType *T) {
   assert((T->getVectorKind() == VectorType::SveFixedLengthDataVector ||
           T->getVectorKind() == VectorType::SveFixedLengthPredicateVector) &&
          "expected fixed-length SVE vector!");
 
   QualType EltType = T->getElementType();
   assert(EltType->isBuiltinType() &&
          "expected builtin type for fixed-length SVE vector!");

clang/lib/Format/Format.cpp

FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
 
   if (Language == FormatStyle::LK_Java) {
     ChromiumStyle.AllowShortIfStatementsOnASingleLine =
         FormatStyle::SIS_WithoutElse;
     ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
     ChromiumStyle.ContinuationIndentWidth = 8;
     ChromiumStyle.IndentWidth = 4;
     // See styleguide for import groups:
-    // https://chromium.googlesource.com/chromium/src/+/master/styleguide/java/java.md#Import-Order
+    // https://chromium.googlesource.com/chromium/src/+/refs/heads/main/styleguide/java/java.md#Import-Order
     ChromiumStyle.JavaImportGroups = {
         "android",
         "androidx",
         "com",
         "dalvik",
         "junit",
         "org",
         "com.google.android.apps.chrome",

clang/lib/Format/FormatToken.h

struct AdditionalKeywords {
   /// Returns \c true if \p Tok is a true JavaScript identifier, returns
   /// \c false if it is a keyword or a pseudo keyword.
   /// If \c AcceptIdentifierName is true, returns true not only for keywords,
   // but also for IdentifierName tokens (aka pseudo-keywords), such as
   // ``yield``.
   bool IsJavaScriptIdentifier(const FormatToken &Tok,
                               bool AcceptIdentifierName = true) const {
     // Based on the list of JavaScript & TypeScript keywords here:
-    // https://github.com/microsoft/TypeScript/blob/master/src/compiler/scanner.ts#L74
+    // https://github.com/microsoft/TypeScript/blob/main/src/compiler/scanner.ts#L74
     switch (Tok.Tok.getKind()) {
     case tok::kw_break:
     case tok::kw_case:
     case tok::kw_catch:
     case tok::kw_class:
     case tok::kw_continue:
     case tok::kw_const:
     case tok::kw_default:

clang/lib/Format/TokenAnnotator.cpp

if (Style.isCSharp()) {
     if (Left.is(TT_NonNullAssertion))
       return true;
     if (Left.is(Keywords.kw_declare) &&
         Right.isOneOf(Keywords.kw_module, tok::kw_namespace,
                       Keywords.kw_function, tok::kw_class, tok::kw_enum,
                       Keywords.kw_interface, Keywords.kw_type, Keywords.kw_var,
                       Keywords.kw_let, tok::kw_const))
       // See grammar for 'declare' statements at:
-      // https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#A.10
+      // https://github.com/Microsoft/TypeScript/blob/main/doc/spec-ARCHIVED.md#A.10
       return false;
     if (Left.isOneOf(Keywords.kw_module, tok::kw_namespace) &&
         Right.isOneOf(tok::identifier, tok::string_literal))
       return false; // must not break in "module foo { ...}"
     if (Right.is(TT_TemplateString) && Right.closesScope())
       return false;
     // Don't split tagged template literal so there is a break between the tag
     // identifier and template string.

clang/test/OpenMP/aarch64_vfabi_NarrowestDataSize.c

 // RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +neon -fopenmp      -x c -emit-llvm %s -o - -femit-all-decls | FileCheck %s
 // RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +neon -fopenmp-simd -x c -emit-llvm %s -o - -femit-all-decls | FileCheck %s
 
 // REQUIRES: aarch64-registered-target
 // Note: -fopemp and -fopenmp-simd behavior are expected to be the same.
 
 // This test checks the values of Narrowest Data Size (NDS), as defined in
-// https://github.com/ARM-software/abi-aa/tree/master/vfabia64
+// https://github.com/ARM-software/abi-aa/tree/main/vfabia64
 //
 // NDS is used to compute the <vlen> token in the name of AdvSIMD
 // vector functions when no `simdlen` is specified, with the rule:
 //
 // if NDS(f) = 1, then VLEN = 16, 8;
 // if NDS(f) = 2, then VLEN = 8, 4;
 // if NDS(f) = 4, then VLEN = 4, 2;
 // if NDS(f) = 8 or NDS(f) = 16, then VLEN = 2.

clang/test/OpenMP/aarch64_vfabi_WidestDataSize.c

 // RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +sve  -fopenmp      -x c -emit-llvm %s -o - -femit-all-decls | FileCheck %s
 // RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +sve  -fopenmp-simd -x c -emit-llvm %s -o - -femit-all-decls | FileCheck %s
 
 // REQUIRES: aarch64-registered-target
 // Note: -fopemp and -fopenmp-simd behavior are expected to be the same.
 
 // This test checks the values of Widest Data Size (WDS), as defined
-// in https://github.com/ARM-software/abi-aa/tree/master/vfabia64
+// in https://github.com/ARM-software/abi-aa/tree/main/vfabia64
 //
 // WDS is used to check the accepted values <N> of `simdlen(<N>)` when
 // targeting fixed-length SVE vector function names. The values of
 // `<N>` that are accepted are such that for X = WDS * <N> * 8,
 // 128-bit <= X <= 2048-bit and X is a multiple of 128-bit.
 
 #pragma omp declare simd simdlen(8)
 #pragma omp declare simd simdlen(16)

clang/www/related.html

<dl>
           This is an effort to get FreeBSD to build with clang/llvm.
         </p>
       </dd>
 
       <dt>Chromium Clang Page</dt>
       <dd>
         <p>
           <b>Site:</b>
-          <a href="https://chromium.googlesource.com/chromium/src/+/master/docs/clang.md">
-            https://chromium.googlesource.com/chromium/src/+/master/docs/clang.md</a>
+          <a href="https://chromium.googlesource.com/chromium/src/+/refs/heads/main/docs/clang.md">
+            https://chromium.googlesource.com/chromium/src/+/refs/heads/main/docs/clang.md</a>
         </p>
         <p>
           Notes on using Clang to build the Chromium web browser.
         </p>
       </dd>
 
       <dt>Debian Clang Page</dt>
       <dd>

libcxx/utils/ci/Dockerfile

 RUN apt-get update && apt-get install -y sudo
 RUN echo "ALL ALL = (ALL) NOPASSWD: ALL" >> /etc/sudoers
 RUN useradd --create-home libcxx-builder
 USER libcxx-builder
 WORKDIR /home/libcxx-builder
 
 # Install the Buildkite agent and dependencies. This must be done as non-root
 # for the Buildkite agent to be installed in a path where we can find it.
-RUN bash -c "$(curl -sL https://raw.githubusercontent.com/buildkite/agent/master/install.sh)"
+RUN bash -c "$(curl -sL https://raw.githubusercontent.com/buildkite/agent/main/install.sh)"
 ENV PATH="${PATH}:/home/libcxx-builder/.buildkite-agent/bin"
 RUN echo "tags=\"queue=libcxx-builders,arch=$(uname -m),os=linux\"" >> "/home/libcxx-builder/.buildkite-agent/buildkite-agent.cfg"
 
 # By default, start the Buildkite agent (this requires a token).
 CMD buildkite-agent start

lld/docs/WebAssembly.rst

 
 Missing features
 ----------------
 
 - Merging of data section similar to ``SHF_MERGE`` in the ELF world is not
   supported.
 - No support for creating shared libraries.  The spec for shared libraries in
   WebAssembly is still in flux:
-  https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+  https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
 
-.. _linking: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md
+.. _linking: https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md

lld/wasm/Driver.cpp

if (config->isPic) {
     WasmSym::stackPointer =
         createUndefinedGlobal("__stack_pointer", config->is64.getValueOr(false)
                                                      ? &mutableGlobalTypeI64
                                                      : &mutableGlobalTypeI32);
     // For PIC code, we import two global variables (__memory_base and
     // __table_base) from the environment and use these as the offset at
     // which to load our static data and function table.
     // See:
-    // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+    // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
     auto *globalType = is64 ? &globalTypeI64 : &globalTypeI32;
     WasmSym::memoryBase = createUndefinedGlobal("__memory_base", globalType);
     WasmSym::tableBase = createUndefinedGlobal("__table_base", globalType);
     WasmSym::memoryBase->markLive();
     WasmSym::tableBase->markLive();
     if (is64) {
       WasmSym::tableBase32 =
           createUndefinedGlobal("__table_base32", &globalTypeI32);

lld/wasm/SyntheticSections.h

 
 protected:
   llvm::raw_string_ostream bodyOutputStream;
 };
 
 // Create the custom "dylink" section containing information for the dynamic
 // linker.
 // See
-// https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+// https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
 class DylinkSection : public SyntheticSection {
 public:
   DylinkSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "dylink.0") {}
   bool isNeeded() const override { return config->isPic; }
   void writeBody() override;
 
   uint32_t memAlign = 0;
   uint32_t memSize = 0;

lldb/unittests/Process/minidump/Inputs/linux-x86_64.cpp

 // Example source from breakpad's linux tutorial
-// https://chromium.googlesource.com/breakpad/breakpad/+/master/docs/linux_starter_guide.md
+// https://chromium.googlesource.com/breakpad/breakpad/+/main/docs/linux_starter_guide.md
 
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "client/linux/handler/exception_handler.h"
 
 static bool dumpCallback(const google_breakpad::MinidumpDescriptor &descriptor,

llvm/CMakeLists.txt

 set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
 
 if(LLVM_INCLUDE_TESTS)
   include(GetErrcMessages)
   get_errc_messages(LLVM_LIT_ERRC_MESSAGES)
 endif()
 
 # For up-to-date instructions for installing the Tensorflow dependency, refer to
-# the bot setup script: https://github.com/google/ml-compiler-opt/blob/master/buildbot/buildbot_init.sh
+# the bot setup script: https://github.com/google/ml-compiler-opt/blob/main/buildbot/buildbot_init.sh
 # In this case, the latest C API library is available for download from
 # https://www.tensorflow.org/install/lang_c.
 # We will expose the conditional compilation variable,
 # LLVM_HAVE_TF_API, through llvm-config.h, so that a user of the LLVM library may
 # also leverage the dependency.
 set(TENSORFLOW_C_LIB_PATH "" CACHE PATH "Path to TensorFlow C library install")
 if (TENSORFLOW_C_LIB_PATH)
   find_library(tensorflow_c_api tensorflow PATHS ${TENSORFLOW_C_LIB_PATH}/lib NO_DEFAULT_PATH REQUIRED)
if (TENSORFLOW_C_LIB_PATH)
   endif()
   message(STATUS "Using Tensorflow headers under: ${TF_PROTO_HEADERS}")
   include_directories(${TF_PROTO_HEADERS})
   add_definitions("-DGOOGLE_PROTOBUF_NO_RTTI")
   add_definitions("-D_GLIBCXX_USE_CXX11_ABI=0")
 endif()
 
 # For up-to-date instructions for installing the Tensorflow dependency, refer to
-# the bot setup script: https://github.com/google/ml-compiler-opt/blob/master/buildbot/buildbot_init.sh
+# the bot setup script: https://github.com/google/ml-compiler-opt/blob/main/buildbot/buildbot_init.sh
 # Specifically, assuming python3 is installed:
 # python3 -m pip install --upgrade pip && python3 -m pip install --user tf_nightly==2.3.0.dev20200528
 # Then set TENSORFLOW_AOT_PATH to the package install - usually it's ~/.local/lib/python3.7/site-packages/tensorflow
 #
 set(TENSORFLOW_AOT_PATH "" CACHE PATH "Path to TensorFlow pip install dir")
 
 if (NOT TENSORFLOW_AOT_PATH STREQUAL "")
   set(LLVM_HAVE_TF_AOT "ON" CACHE BOOL "Tensorflow AOT available")

llvm/docs/CompileCudaWithLLVM.rst

 
 In clang and nvcc, most of the C++ standard library is not supported on the
 device side.
 
 ``<math.h>`` and ``<cmath>``
 ----------------------------
 
 In clang, ``math.h`` and ``cmath`` are available and `pass
-<https://github.com/llvm/llvm-test-suite/blob/master/External/CUDA/math_h.cu>`_
+<https://github.com/llvm/llvm-test-suite/blob/main/External/CUDA/math_h.cu>`_
 `tests
-<https://github.com/llvm/llvm-test-suite/blob/master/External/CUDA/cmath.cu>`_
+<https://github.com/llvm/llvm-test-suite/blob/main/External/CUDA/cmath.cu>`_
 adapted from libc++'s test suite.
 
 In nvcc ``math.h`` and ``cmath`` are mostly available.  Versions of ``::foof``
 in namespace std (e.g. ``std::sinf``) are not available, and where the standard
 calls for overloads that take integral arguments, these are usually not
 available.
 
 .. code-block:: c++

llvm/docs/Proposals/TestSuite.rst

  * Havoq
 
 NWChem
 ------
 http://www.nwchem-sw.org/index.php/Benchmarks
 
 TVM
 ----
-https://github.com/dmlc/tvm/tree/master/apps/benchmark
+https://github.com/dmlc/tvm/tree/main/apps/benchmark
 
 HydroBench
 ----------
 https://github.com/HydroBench/Hydro
 
 ParRes
 ------
-https://github.com/ParRes/Kernels/tree/master/Cxx11
+https://github.com/ParRes/Kernels/tree/default/Cxx11
 
 Applications/Libraries
 ======================
 
 GnuPG
 -----
 https://gnupg.org/
 

llvm/include/llvm/BinaryFormat/Wasm.h

 //===- Wasm.h - Wasm object file format -------------------------*- 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 manifest constants for the wasm object file format.
-// See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
+// See: https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BINARYFORMAT_WASM_H
 #define LLVM_BINARYFORMAT_WASM_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"

llvm/include/llvm/Object/Wasm.h

 //===- Wasm.h - Wasm object file implementation -----------------*- 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 WasmObjectFile class, which implements the ObjectFile
 // interface for Wasm files.
 //
-// See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
+// See: https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_WASM_H
 #define LLVM_OBJECT_WASM_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"

llvm/lib/MC/WasmObjectWriter.cpp

uint32_t WasmObjectWriter::writeDataSection(const MCAsmLayout &Layout) {
 
   endSection(Section);
   return Section.Index;
 }
 
 void WasmObjectWriter::writeRelocSection(
     uint32_t SectionIndex, StringRef Name,
     std::vector<WasmRelocationEntry> &Relocs) {
-  // See: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md
+  // See: https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md
   // for descriptions of the reloc sections.
 
   if (Relocs.empty())
     return;
 
   // First, ensure the relocations are sorted in offset order.  In general they
   // should already be sorted since `recordRelocation` is called in offset
   // order, but for the code section we combine many MC sections into single

llvm/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("dylink section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseDylink0Section(ReadContext &Ctx) {
   // See
-  // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+  // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
   HasDylinkSection = true;
 
   const uint8_t *OrigEnd = Ctx.End;
   while (Ctx.Ptr < OrigEnd) {
     Ctx.End = OrigEnd;
     uint8_t Type = readUint8(Ctx);
     uint32_t Size = readVaruint32(Ctx);
     LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size

llvm/lib/Target/WebAssembly/README.txt

 //===-- README.txt - Notes for WebAssembly code gen -----------------------===//
 
 The object format emitted by the WebAssembly backed is documented in:
 
-  * https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md
+  * https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md
 
 The C ABI is described in:
 
-  * https://github.com/WebAssembly/tool-conventions/blob/master/BasicCABI.md
+  * https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md
 
 For more information on WebAssembly itself, see the home page:
 
   * https://webassembly.github.io/
 
 Emscripten provides a C/C++ compilation environment based on clang which
 includes standard libraries, tools, and packaging for producing WebAssembly
 applications that can run in browsers and other environments.
 
 wasi-sdk provides a more minimal C/C++ SDK based on clang, llvm and a libc based
 on musl, for producing WebAssemmbly applictions that use the WASI ABI.
 
 Rust provides WebAssembly support integrated into Cargo. There are two
 main options:
  - wasm32-unknown-unknown, which provides a relatively minimal environment
    that has an emphasis on being "native"
  - wasm32-unknown-emscripten, which uses Emscripten internally and
    provides standard C/C++ libraries, filesystem emulation, GL and SDL
    bindings
 For more information, see:
   * https://www.hellorust.com/
 
 The following documents contain some information on the semantics and binary
 encoding of WebAssembly itself:
-  * https://github.com/WebAssembly/design/blob/master/Semantics.md
-  * https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
+  * https://github.com/WebAssembly/design/blob/main/Semantics.md
+  * https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md
 
 Some notes on ways that the generated code could be improved follow:
 
 //===---------------------------------------------------------------------===//
 
 Br, br_if, and br_table instructions can support having a value on the value
 stack across the jump (sometimes). We should (a) model this, and (b) extend
 the stackifier to utilize it.

llvm/tools/vfabi-demangle-fuzzer/vfabi-demangler-fuzzer.cpp

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   // zeroes.
   if (!MangledName.empty() && MangledName.find_first_of(0) == StringRef::npos)
     M->getOrInsertFunction(
         MangledName,
         FunctionType::get(Type::getVoidTy(M->getContext()), false));
   const auto Info = VFABI::tryDemangleForVFABI(MangledName, *M);
 
   // Do not optimize away the return value. Inspired by
-  // https://github.com/google/benchmark/blob/master/include/benchmark/benchmark.h#L307-L345
+  // https://github.com/google/benchmark/blob/main/include/benchmark/benchmark.h#L307-L345
   asm volatile("" : : "r,m"(Info) : "memory");
 
   return 0;
 }

llvm/utils/gn/README.rst

 the host arch. You can set build options by editing ``out/gn/args.gn``, for
 example putting ``is_debug = true`` in there gives you a debug build. Run
 ``llvm/utils/gn/gn.py args --list out/gn`` to see a list of all possible
 options. After touching ``out/gn/args.gn`` just run ninja: it will re-invoke gn
 before starting the build.
 
 GN has extensive built-in help; try e.g. ``llvm/utils/gn/gn.py help gen`` to see
 the help for the ``gen`` command. The full GN reference is also `available
-online <https://gn.googlesource.com/gn/+/master/docs/reference.md>`_.
+online <https://gn.googlesource.com/gn/+/refs/heads/main/docs/reference.md>`_.
 
 GN has an autoformatter:
 ``git ls-files '*.gn' '*.gni' | xargs llvm/utils/gn/gn.py format``
 after making GN build changes is your friend.
 
 To not put ``BUILD.gn`` files into the main tree, they are all below
 ``utils/gn/secondary``.  For example, the build file for ``llvm/lib/Support``
 is in ``utils/gn/secondary/llvm/lib/Support``.

mlir/docs/Dialects/SPIR-V.md

 [MlirSpirvPasses]: https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.h
 [MlirSpirvConversion]: https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h
 [MlirSpirvAbi]: https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Dialect/SPIRV/IR/TargetAndABI.h
 [MlirSpirvOpsCpp]: https://github.com/llvm/llvm-project/blob/main/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
 [GitHubDialectTracking]: https://github.com/tensorflow/mlir/issues/302
 [GitHubLoweringTracking]: https://github.com/tensorflow/mlir/issues/303
 [GenSpirvUtilsPy]: https://github.com/llvm/llvm-project/blob/main/mlir/utils/spirv/gen_spirv_dialect.py
 [CustomTypeAttrTutorial]: ../Tutorials/DefiningAttributesAndTypes.md
-[VulkanExtensionPhysicalStorageBuffer]: https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/KHR/SPV_KHR_physical_storage_buffer.html
-[VulkanExtensionVariablePointers]: https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/KHR/SPV_KHR_variable_pointers.html
+[VulkanExtensionPhysicalStorageBuffer]: https://github.com/KhronosGroup/SPIRV-Registry/blob/main/extensions/KHR/SPV_KHR_physical_storage_buffer.html
+[VulkanExtensionVariablePointers]: https://github.com/KhronosGroup/SPIRV-Registry/blob/main/extensions/KHR/SPV_KHR_variable_pointers.html
 [VulkanSpirv]: https://renderdoc.org/vkspec_chunked/chap40.html#spirvenv
 [VulkanShaderInterface]: https://renderdoc.org/vkspec_chunked/chap14.html#interfaces-resources
 [VulkanShaderInterfaceStorageClass]: https://renderdoc.org/vkspec_chunked/chap15.html#interfaces
 [VulkanResourceLimits]: https://renderdoc.org/vkspec_chunked/chap36.html#limits
 [VulkanGPUInfoMaxPerStageDescriptorStorageBuffers]: https://vulkan.gpuinfo.org/displaydevicelimit.php?name=maxPerStageDescriptorStorageBuffers&platform=android
 [VulkanPushConstants]: https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushConstants.html

mlir/docs/LangRef.md

 # MLIR Language Reference
 
 MLIR (Multi-Level IR) is a compiler intermediate representation with
 similarities to traditional three-address SSA representations (like
 [LLVM IR](http://llvm.org/docs/LangRef.html) or
-[SIL](https://github.com/apple/swift/blob/master/docs/SIL.rst)), but which
+[SIL](https://github.com/apple/swift/blob/main/docs/SIL.rst)), but which
 introduces notions from polyhedral loop optimization as first-class concepts.
 This hybrid design is optimized to represent, analyze, and transform high level
 dataflow graphs as well as target-specific code generated for high performance
 data parallel systems. Beyond its representational capabilities, its single
 continuous design provides a framework to lower from dataflow graphs to
 high-performance target-specific code.
 
 This document defines and describes the key concepts in MLIR, and is intended to

mlir/docs/Rationale/Rationale.md

 # MLIR Rationale
 
 This document is intended to capture some of the alternatives considered and
 open debates in the design of MLIR, along with the rationale for certain
 decisions we made. This is not intended to be a "finely groomed" document - we
 prefer the ability to dump in interesting tidbits without worrying too much
 about their consistency or readability.
 
 [TOC]
 
 ## Abstract
 
 MLIR is a compiler intermediate representation with similarities to traditional
 three-address SSA representations (like
 [LLVM IR](http://llvm.org/docs/LangRef.html) or
-[SIL](https://github.com/apple/swift/blob/master/docs/SIL.rst)), but which
+[SIL](https://github.com/apple/swift/blob/main/docs/SIL.rst)), but which
 introduces notions from the polyhedral loop optimization works as first class
 concepts. This hybrid design is optimized to represent, analyze, and transform
 high level dataflow graphs as well as target-specific code generated for high
 performance data parallel systems. Beyond its representational capabilities, its
 single continuous design provides a framework to lower from dataflow graphs to
 high performance target specific code.
 
 MLIR stands for one of "Multi-Level IR" or "Multi-dimensional Loop IR" or
1.  The entry list of PHI nodes in LLVM are unordered, and some blocks have
     time problems because transformations have to linearly scan this list. This
     is defined away with BB argument representation.
 1.  LLVM has no way to represent values that are available only in one successor
     but not the other, e.g. its invoke instruction cannot produce the exception
     value JUST on the exception edge. Instead, the
     [landingpad instruction](http://llvm.org/docs/LangRef.html#landingpad-instruction)
     is a hack used to represent this. MLIR doesn't make use of this capability,
     but SIL uses it extensively, e.g. in the
-    [switch_enum instruction](https://github.com/apple/swift/blob/master/docs/SIL.rst#switch-enum).
+    [switch_enum instruction](https://github.com/apple/swift/blob/main/docs/SIL.rst#switch-enum).
 
 For more context, block arguments were previously used in the Swift
-[SIL Intermediate Representation](https://github.com/apple/swift/blob/master/docs/SIL.rst),
+[SIL Intermediate Representation](https://github.com/apple/swift/blob/main/docs/SIL.rst),
 and described in
 [a talk on YouTube](https://www.youtube.com/watch?v=Ntj8ab-5cvE). The section of
 interest
 [starts here](https://www.google.com/url?q=https://youtu.be/Ntj8ab-5cvE?t%3D596&sa=D&ust=1529450150971000&usg=AFQjCNFQHEWL7m8q3eO-1DiKw9zqC2v24Q).
 
 ### Index type usage and limitations
 
 Index types are intended to be used for platform-specific "size" values and may

mlir/docs/Rationale/RationaleGenericDAGRewriter.md

 GCC
 ["combine" routines](https://github.com/gcc-mirror/gcc/blob/master/gcc/combine.c)
 (which try to merge two machine instructions into a single one), the LLVM
 [Inst Combine](https://github.com/llvm/llvm-project/tree/main/llvm/lib/Transforms/InstCombine)
 [pass](https://llvm.org/docs/Passes.html#instcombine-combine-redundant-instructions),
 LLVM's
 [DAG Combiner](https://github.com/llvm-mirror/llvm/blob/master/lib/CodeGen/SelectionDAG/DAGCombiner.cpp),
 the Swift compiler's
-[SIL Combiner](https://github.com/apple/swift/tree/master/lib/SILOptimizer/SILCombiner),
+[SIL Combiner](https://github.com/apple/swift/tree/main/lib/SILOptimizer/SILCombiner),
 etc. These generally match one or more operations and produce zero or more
 operations as a result. The LLVM
 [Legalization](https://github.com/llvm/llvm-project/tree/main/llvm/lib/CodeGen/SelectionDAG)
 infrastructure has a different outer loop but otherwise works the same way.
 
 These passes have a lot of diversity, but also have a unifying structure: they
 mostly have a worklist outer loop which visits operations. They then use a
 visitor pattern (or equivalent) to switch over the class of operation and

mlir/include/mlir/Dialect/LLVMIR/ROCDLDialect.h

 //===- ROCDLDialect.h - MLIR ROCDL IR 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 ROCDL dialect in MLIR, containing ROCDL operations
 // and ROCDL specific extensions to the LLVM type system.
 //
 // Unfortunately there does not exists a formal definition of ROCDL IR that be
 // pointed to here. However the following links contain more information about
 // ROCDL (ROCm-Device-Library)
 //
-// https://github.com/RadeonOpenCompute/ROCm-Device-Libs/blob/master/doc/OCML.md
-// https://github.com/RadeonOpenCompute/ROCm-Device-Libs/blob/master/doc/OCKL.md
+// https://github.com/RadeonOpenCompute/ROCm-Device-Libs/blob/amd-stg-open/doc/OCML.md
+// https://github.com/RadeonOpenCompute/ROCm-Device-Libs/blob/amd-stg-open/doc/OCKL.md
 // https://llvm.org/docs/AMDGPUUsage.html
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LLVMIR_ROCDLDIALECT_H_
 #define MLIR_DIALECT_LLVMIR_ROCDLDIALECT_H_
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"

mlir/lib/Tools/mlir-lsp-server/lsp/Protocol.h

 //===--- Protocol.h - Language Server Protocol Implementation ---*- 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 structs based on the LSP specification at
-// https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md
+// https://github.com/Microsoft/language-server-protocol/blob/main/protocol.md
 //
 // This is not meant to be a complete implementation, new interfaces are added
 // when they're needed.
 //
 // Each struct has a toJSON and fromJSON function, that converts between
 // the struct and a JSON representation. (See JSON.h)
 //
 // Some structs also have operator<< serialization. This is for debugging and

utils/bazel/.bazelrc

 build:rbe --javabase=@rbe_default//java:jdk
 build:rbe --host_java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8
 build:rbe --java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8
 build:rbe --crosstool_top=@rbe_default//cc:toolchain
 build:rbe --action_env=BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1
 # Platform flags:
 # The toolchain container used for execution is defined in the target indicated
 # by "extra_execution_platforms", "host_platform" and "platforms".
-# More about platforms: https://docs.bazel.build/versions/master/platforms.html
+# More about platforms: https://docs.bazel.build/versions/main/platforms.html
 build:rbe --extra_toolchains=@rbe_default//config:cc-toolchain
 build:rbe --extra_execution_platforms=@rbe_default//config:platform
 build:rbe --host_platform=@rbe_default//config:platform
 build:rbe --platforms=@rbe_default//config:platform
 
 build:rbe --define=EXECUTOR=remote
 
 # Enable remote execution so actions are performed on the remote systems.

utils/bazel/README.md

 for adding this configuration.
 
 # Quick Start
 
 1. `git clone https://github.com/llvm/llvm-project.git; cd llvm-project` if
    you don't have a checkout yet.
 2. Install Bazel at the version indicated by [.bazelversion](./.bazelversion),
    following the official instructions, if you don't have it installed yet:
-   https://docs.bazel.build/versions/master/install.html.
+   https://docs.bazel.build/versions/main/install.html.
 3. `cd utils/bazel`
 4. `bazel build --config=generic_clang @llvm-project//...` (if building on Unix
    with Clang). `--config=generic_gcc` and `--config=msvc` are also available.
 
 
 # Configuration
 
 The repository `.bazelrc` will import user-specific settings from a
 `user.bazelrc` file (in addition to the standard locations). Adding your typical
 config setting is recommended.
 
 ```.bazelrc
 build --config=generic_clang
 ```
 
 You can enable
-[disk caching](https://docs.bazel.build/versions/master/remote-caching.html#disk-cache),
+[disk caching](https://docs.bazel.build/versions/main/remote-caching.html#disk-cache),
 which will cache build results
 
 ```.bazelrc
 build --disk_cache=~/.cache/bazel-disk-cache
 ```
 
 You can instruct Bazel to use a ramdisk for its sandboxing operations via
-[--sandbox_base](https://docs.bazel.build/versions/master/command-line-reference.html#flag--sandbox_base),
+[--sandbox_base](https://docs.bazel.build/versions/main/command-line-reference.html#flag--sandbox_base),
 which can help avoid IO bottlenecks for the symlink stragegy used for
 sandboxing. This is especially important with many inputs and many cores (see
 https://github.com/bazelbuild/bazel/issues/11868):
 
 ```.bazelrc
 build --sandbox_base=/dev/shm
 ```