Bug 1941482 - Enable Clang 20 support for Firefox with Windows plugin fixes r=glandium

This change adds support for building Firefox with Clang 20, including
critical fixes for the clang-plugin dynamic linking on Windows.

Clang 20 introduced two breaking changes that prevented the clang-plugin
from loading on Windows:

1. The CLANG_ABI macro was added to Attr classes, causing inline methods
   like classof() and getAnnotation() to generate dllimport references.
   This fails because these methods are defined inline in headers, not
   exported from the DLL.

2. The extract_symbols.py script became more aggressive in filtering
   symbols, blocking Registry<T> static data members (Head/Tail) that
   don't match function signature patterns.

The fix consists of three patches for the Clang 20 build:

- add-plugin-symbols_clang_20.patch: Adds pattern matching to
  extract_symbols.py to recognize and export Registry<T>::Head and
  ::Tail static members for any Registry instantiation. This replaces
  the need for hardcoded symbol whitelists and works across different
  plugin types.

  See llvm/llvm-project#163367 and
  llvm/llvm-project#163391.

- force-plugin-symbols_clang_20.patch: Adds C++ code to driver.cpp that
  references Registry<PluginASTAction>::add_node() and ::begin() to force
  the linker to include these symbols. This replaces hardcoded mangled
  symbol names with type-safe references that work across compiler versions.

  See llvm/llvm-project#163367 and
  llvm/llvm-project#163391.

- remove-clang-abi-from-attrs_clang_20.patch: Removes the CLANG_ABI
  macro from Attr class generation to prevent dllimport issues with
  inline methods.

  See llvm/llvm-project#163349.

To test this locally:

- Install the current clang-20 inside the firefox checkout:

`./mach artifact toolchain --from-build win64-clang-20`

- Install libxml2 (necessary for clang-mt.exe):

`./mach artifact toolchain --from-build win64-libxml2`

- Install wasm32-wasi-compiler-rt-20 (necessary for WASM compilation?):

`./mach artifact toolchain --from-build wasm32-wasi-compiler-rt-20`

- Check out llvm 20.1.8 in a directory alongside the firefox checkout.
- Try to build llvm, and fail when the wasi lib is missing:

`MOZ_FETCHES_DIR=../firefox python3 ../firefox/build/build-clang/build-clang.py -c ../firefox/build/build-clang/use-clang-cl-artifact.json -c ../firefox/build/build-clang/win64.json -c ../firefox/build/build-clang/clang-20.json -c ../firefox/build/build-clang/2stages.json`

- Copy the missing wasi lib to the stage2 build directory:

```
mkdir build/stage2/clang/lib/clang/20/lib/wasm32-unknown-wasi
cp ../firefox/compiler-rt-wasm32-wasi/lib/wasi/libclang_rt.builtins-wasm32.a build/stage2/clang/lib/clang/20/lib/wasm32-unknown-wasi/libclang_rt.builtins.a
```

- Try to build llvm again and succeed:

`MOZ_FETCHES_DIR=../firefox python3 ../firefox/build/build-clang/build-clang.py -c ../firefox/build/build-clang/use-clang-cl-artifact.json -c ../firefox/build/build-clang/win64.json -c ../firefox/build/build-clang/clang-20.json -c ../firefox/build/build-clang/2stages.json`

- Update the mozconfig in the firefox checkout to turn on the clang
  plugin and use the right compiler:

```
export CC=[THE LLVM CHECKOUT DIRECTORY]/build/stage2/clang/bin/clang-cl.exe
ac_add_options --enable-clang-plugin
```

- Build firefox:

`./mach clobber && ./mach configure --enable-bootstrap=no-update && ./mach build`

Differential Revision: https://phabricator.services.mozilla.com/D268255

Author: zond

build/build-clang/add-plugin-symbols_clang_20.patch

@@ -0,0 +1,21 @@
+Export Registry<T> Head and Tail symbols for plugin support.
+
+Clang 20's extract_symbols.py filters static data members that don't match
+function signatures. Add pattern matching for Registry<T>::Head and ::Tail.
+
+diff --git a/llvm/utils/extract_symbols.py b/llvm/utils/extract_symbols.py
+index 388723421d66..72f992f560c7 100755
+--- a/llvm/utils/extract_symbols.py
++++ b/llvm/utils/extract_symbols.py
+@@ -105,6 +105,11 @@ def should_keep_microsoft_symbol(symbol, calling_convention_decoration):
+     # Skip X86GenMnemonicTables functions, they are not exposed from llvm/include/.
+     elif re.match(r"\?is[A-Z0-9]*@X86@llvm", symbol):
+         return None
++    # Keep Registry<T>::Head and Registry<T>::Tail static members for plugin support.
++    # Pattern matches: ?Head@?$Registry@<template_args>@llvm@@ or ?Tail@?$Registry@...
++    elif ("?$Registry@" in symbol and "@llvm@@" in symbol and
++          (symbol.startswith("?Head@") or symbol.startswith("?Tail@"))):
++        return symbol
+     # Keep mangled llvm:: and clang:: function symbols. How we detect these is a
+     # bit of a mess and imprecise, but that avoids having to completely demangle
+     # the symbol name. The outermost namespace is at the end of the identifier

build/build-clang/clang-20.json

@@ -12,6 +12,9 @@
         "llvmorg-22-init-4745-gbe179d069664.patch",
         "android-hardware-buffer-header-workaround.patch",
         "arm64e-hack.patch",
-        "compiler-rt-rss-limit-heap-profile.patch"
+        "compiler-rt-rss-limit-heap-profile.patch",
+        "add-plugin-symbols_clang_20.patch",
+        "force-plugin-symbols_clang_20.patch",
+        "remove-clang-abi-from-attrs_clang_20.patch"
     ]
 }

build/build-clang/force-plugin-symbols_clang_20.patch

@@ -0,0 +1,36 @@
+Force plugin registry symbols into clang.exe for Windows plugin support.
+
+Add C++ code that references Registry<PluginASTAction>::add_node() and ::begin()
+to force the linker to include these symbols. This replaces hardcoded mangled symbol
+names with type-safe references that work across compiler versions.
+
+diff --git a/clang/tools/driver/driver.cpp b/clang/tools/driver/driver.cpp
+index 00c00cea16f4..d2622e679a47 100644
+--- a/clang/tools/driver/driver.cpp
++++ b/clang/tools/driver/driver.cpp
+@@ -55,6 +55,25 @@
+ #include <set>
+ #include <system_error>
+
++#if defined(CLANG_PLUGIN_SUPPORT) && defined(_WIN32)
++#include "clang/Frontend/FrontendPluginRegistry.h"
++
++// Force plugin registry symbols into clang.exe on Windows so plugins can
++// register. These methods exist in libraries but aren't linked by default
++// because they're unreferenced. Taking their addresses forces the linker to
++// include them.
++namespace {
++void ForcePluginRegistrySymbols() {
++  using PluginRegistry = llvm::Registry<clang::PluginASTAction>;
++  // Use volatile to prevent the compiler from optimizing away these references
++  volatile auto add_node_ptr = &PluginRegistry::add_node;
++  volatile auto begin_ptr = &PluginRegistry::begin;
++  (void)add_node_ptr;
++  (void)begin_ptr;
++}
++} // anonymous namespace
++#endif
++
+ using namespace clang;
+ using namespace clang::driver;
+ using namespace llvm::opt;

build/build-clang/remove-clang-abi-from-attrs_clang_20.patch

@@ -0,0 +1,19 @@
+Remove CLANG_ABI macro from generated Attr classes to fix Windows plugin builds.
+
+Clang 20 added CLANG_ABI (__declspec(dllimport)) to Attr classes, but this breaks
+inline methods like classof() and getAnnotation() that are defined in headers.
+These can't be imported as they have no DLL export. This reverts to Clang 19 behavior.
+
+diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp
+index de12c7062666..38e1db6b3ea4 100644
+--- a/clang/utils/TableGen/ClangAttrEmitter.cpp
++++ b/clang/utils/TableGen/ClangAttrEmitter.cpp
+@@ -2723,7 +2723,7 @@ static void emitAttributes(const RecordKeeper &Records, raw_ostream &OS,
+     }
+ 
+     if (Header)
+-      OS << "class CLANG_ABI " << R.getName() << "Attr : public " << SuperName
++      OS << "class " << R.getName() << "Attr : public " << SuperName
+          << " {\n";
+     else
+       OS << "\n// " << R.getName() << "Attr implementation\n\n";