Rebase to upstream

.github/workflows/llvm-project-tests.yml

@@ -39,7 +39,7 @@ jobs:
           - windows-2019
           # We're using a specific version of macOS due to:
           # https://github.com/actions/virtual-environments/issues/5900
-          - macOS-11
+          - macOS-latest
     steps:
       - name: Setup Windows
         if: startsWith(matrix.os, 'windows')
@@ -76,17 +76,18 @@ jobs:
           key: sccache-${{ matrix.os }}
           variant: sccache
       - name: Build and Test
+        if: "!startsWith(matrix.os, 'windows')"
         uses: llvm/actions/build-test-llvm-project@main
         env:
           # Workaround for https://github.com/actions/virtual-environments/issues/5900.
           # This should be a no-op for non-mac OSes
           PKG_CONFIG_PATH: /usr/local/Homebrew/Library/Homebrew/os/mac/pkgconfig//12
         with:
-          cmake_args: '-GNinja -DLLVM_ENABLE_PROJECTS="${{ inputs.projects }}" -DCMAKE_BUILD_TYPE=Release -DLLDB_INCLUDE_TESTS=OFF -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache'
+          cmake_args: '-GNinja -DLLVM_ENABLE_PROJECTS="${{ inputs.projects }}" -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="BPF;SBF" -DCMAKE_BUILD_TYPE=Release -DLLDB_INCLUDE_TESTS=OFF -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache'
           build_target:  '${{ inputs.build_target }}'
 
       - name: Build and Test libclc
-        if: "!startsWith(matrix.os, 'windows') && contains(inputs.projects, 'libclc')"
+        if: "!startsWith(matrix.os, 'windows') && !startsWith(matrix.os, 'macOS') && contains(inputs.projects, 'libclc')"
         run: |
           # Make sure all of LLVM libraries that llvm-config needs are built.
           ninja -C build

.github/workflows/llvm-tests.yml

@@ -4,16 +4,16 @@ on:
   workflow_dispatch:
   push:
     ignore-forks: true
-    branches:
-      - 'release/**'
+    #branches:
+    #  - 'release/**'
     paths:
       - 'llvm/**'
       - '.github/workflows/llvm-tests.yml'
       - '.github/workflows/llvm-project-tests.yml'
   pull_request:
     ignore-forks: true
-    branches:
-      - 'release/**'
+    #branches:
+    #  - 'release/**'
     paths:
       - 'llvm/**'
       - '.github/workflows/llvm-tests.yml'
@@ -28,7 +28,7 @@ concurrency:
 
 jobs:
   check_all:
-    if: github.repository_owner == 'llvm'
+    #if: github.repository_owner == 'llvm'
     name: Test llvm,clang,libclc
     uses: ./.github/workflows/llvm-project-tests.yml
     with:
@@ -38,23 +38,22 @@ jobs:
   # These need to be separate from the check_all job, becuase there is not enough disk
   # space to build all these projects on Windows.
   build_lldb:
-    if: github.repository_owner == 'llvm'
     name: Build lldb
     uses: ./.github/workflows/llvm-project-tests.yml
     with:
       build_target: ''
       projects: clang;lldb
 
   check_lld:
-    if: github.repository_owner == 'llvm'
+    #if: github.repository_owner == 'llvm'
     name: Test lld
     uses: ./.github/workflows/llvm-project-tests.yml
     with:
       build_target: check-lld
       projects: lld
 
   abi-dump-setup:
-    if: github.repository_owner == 'llvm'
+    #if: github.repository_owner == 'llvm'
     runs-on: ubuntu-latest
     outputs:
       BASELINE_REF: ${{ steps.vars.outputs.BASELINE_REF }}
@@ -85,7 +84,7 @@ jobs:
           fi
 
   abi-dump:
-    if: github.repository_owner == 'llvm'
+    #if: github.repository_owner == 'llvm'
     needs: abi-dump-setup
     runs-on: ubuntu-latest
     strategy:
@@ -156,7 +155,7 @@ jobs:
         path: llvm.symbols
 
   abi-compare:
-    if: github.repository_owner == 'llvm'
+    #if: github.repository_owner == 'llvm'
     runs-on: ubuntu-latest
     needs:
       - abi-dump-setup

README.md

@@ -1,3 +1,9 @@
+# The LLVM Compiler Infrastructure modified to support Berkley Packet Filter modules written in Rust
+
+This fork of LLVM is used by [this fork of Rust](https://github.com/solana-labs/rust)
+
+---
+
 # The LLVM Compiler Infrastructure
 
 This directory and its sub-directories contain the source code for LLVM,

clang/include/clang/Basic/Attr.td

@@ -399,7 +399,7 @@ def TargetARM : TargetArch<["arm", "thumb", "armeb", "thumbeb"]>;
 def TargetAArch64 : TargetArch<["aarch64"]>;
 def TargetAnyArm : TargetArch<!listconcat(TargetARM.Arches, TargetAArch64.Arches)>;
 def TargetAVR : TargetArch<["avr"]>;
-def TargetBPF : TargetArch<["bpfel", "bpfeb"]>;
+def TargetBPF : TargetArch<["bpfel", "bpfeb", "sbf"]>;
 def TargetMips32 : TargetArch<["mips", "mipsel"]>;
 def TargetAnyMips : TargetArch<["mips", "mipsel", "mips64", "mips64el"]>;
 def TargetMSP430 : TargetArch<["msp430"]>;

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -717,4 +717,7 @@ def err_drv_riscv_unsupported_with_linker_relaxation : Error<
 
 def err_drv_loongarch_invalid_mfpu_EQ : Error<
   "invalid argument '%0' to -mfpu=; must be one of: 64, 32, none, 0 (alias for none)">;
+
+def warn_drv_no_solana_with_bpf : Warning<
+  "'+solana' with bpf target is deprecated; use '-target sbf' instead">;
 }

clang/lib/Basic/Targets.cpp

@@ -241,6 +241,7 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
     return new AVRTargetInfo(Triple, Opts);
   case llvm::Triple::bpfeb:
   case llvm::Triple::bpfel:
+  case llvm::Triple::sbf:
     return new BPFTargetInfo(Triple, Opts);
 
   case llvm::Triple::msp430:

clang/lib/Basic/Targets/BPF.cpp

@@ -12,8 +12,10 @@
 
 #include "BPF.h"
 #include "Targets.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/MacroBuilder.h"
 #include "clang/Basic/TargetBuiltins.h"
+#include "clang/Driver/DriverDiagnostic.h"
 #include "llvm/ADT/StringRef.h"
 
 using namespace clang;
@@ -29,10 +31,13 @@ void BPFTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
   Builder.defineMacro("__bpf__");
   Builder.defineMacro("__BPF__");
+  if (HasSolanaFeature) {
+    Builder.defineMacro("__ELF__");
+  }
 }
 
 static constexpr llvm::StringLiteral ValidCPUNames[] = {"generic", "v1", "v2",
-                                                        "v3", "probe"};
+                                                        "v3", "probe", "sbfv2"};
 
 bool BPFTargetInfo::isValidCPUName(StringRef Name) const {
   return llvm::is_contained(ValidCPUNames, Name);
@@ -49,6 +54,12 @@ ArrayRef<Builtin::Info> BPFTargetInfo::getTargetBuiltins() const {
 
 bool BPFTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
                                          DiagnosticsEngine &Diags) {
+  // TODO: The SBF back-end now provides the sbf target. Issue deprecation
+  // warning directing use of '-target sbf' instead. Eventually remove the
+  // +solana support from the BPF back-end.
+  if (getTriple().getArch() != llvm::Triple::sbf && HasSolanaFeature)
+    Diags.Report(diag::warn_drv_no_solana_with_bpf);
+
   for (const auto &Feature : Features) {
     if (Feature == "+alu32") {
       HasAlu32 = true;

clang/lib/Basic/Targets/BPF.h

@@ -22,10 +22,11 @@ namespace clang {
 namespace targets {
 
 class LLVM_LIBRARY_VISIBILITY BPFTargetInfo : public TargetInfo {
+  bool HasSolanaFeature = false;
   bool HasAlu32 = false;
 
 public:
-  BPFTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
+  BPFTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : TargetInfo(Triple) {
     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
     SizeType = UnsignedLong;
@@ -34,10 +35,28 @@ class LLVM_LIBRARY_VISIBILITY BPFTargetInfo : public TargetInfo {
     IntMaxType = SignedLong;
     Int64Type = SignedLong;
     RegParmMax = 5;
+    if (Triple.getArch() == llvm::Triple::sbf) {
+      HasSolanaFeature = true;
+    } else {
+      for (auto& it : Opts.FeaturesAsWritten) {
+        if (it == "+solana") {
+          HasSolanaFeature = true;
+          break;
+        }
+      }
+    }
     if (Triple.getArch() == llvm::Triple::bpfeb) {
-      resetDataLayout("E-m:e-p:64:64-i64:64-i128:128-n32:64-S128");
+      if (HasSolanaFeature) {
+        resetDataLayout("E-m:e-p:64:64-i64:64-n32:64-S128");
+      } else {
+        resetDataLayout("E-m:e-p:64:64-i64:64-i128:128-n32:64-S128");
+      }
     } else {
-      resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n32:64-S128");
+      if (HasSolanaFeature) {
+        resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
+      } else {
+        resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n32:64-S128");
+      }
     }
     MaxAtomicPromoteWidth = 64;
     MaxAtomicInlineWidth = 64;
@@ -48,7 +67,8 @@ class LLVM_LIBRARY_VISIBILITY BPFTargetInfo : public TargetInfo {
                         MacroBuilder &Builder) const override;
 
   bool hasFeature(StringRef Feature) const override {
-    return Feature == "bpf" || Feature == "alu32" || Feature == "dwarfris";
+    return Feature == "bpf" || Feature == "alu32" || Feature == "dwarfris" ||
+      Feature == "solana";
   }
 
   void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
@@ -113,6 +133,8 @@ class LLVM_LIBRARY_VISIBILITY BPFTargetInfo : public TargetInfo {
     StringRef CPUName(Name);
     return isValidCPUName(CPUName);
   }
+
+  bool hasBitIntType() const override { return HasSolanaFeature; }
 };
 } // namespace targets
 } // namespace clang

clang/lib/CodeGen/CGBuiltin.cpp

@@ -5454,6 +5454,7 @@ static Value *EmitTargetArchBuiltinExpr(CodeGenFunction *CGF,
     return CGF->EmitAArch64BuiltinExpr(BuiltinID, E, Arch);
   case llvm::Triple::bpfeb:
   case llvm::Triple::bpfel:
+  case llvm::Triple::sbf:
     return CGF->EmitBPFBuiltinExpr(BuiltinID, E);
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:

clang/lib/Driver/CMakeLists.txt

@@ -30,6 +30,7 @@ add_clang_library(clangDriver
   ToolChain.cpp
   ToolChains/Arch/AArch64.cpp
   ToolChains/Arch/ARM.cpp
+  ToolChains/Arch/BPF.cpp
   ToolChains/Arch/CSKY.cpp
   ToolChains/Arch/LoongArch.cpp
   ToolChains/Arch/M68k.cpp

clang/lib/Driver/ToolChains/Arch/BPF.cpp

@@ -0,0 +1,61 @@
+//===--- BPF.cpp - Tools Implementations ------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "BPF.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+
+using namespace clang::driver;
+using namespace clang::driver::tools;
+using namespace clang;
+using namespace llvm::opt;
+
+static bool DecodeBPFFeatures(const Driver &D, StringRef text,
+                              std::vector<StringRef> &Features) {
+  SmallVector<StringRef, 8> Split;
+  text.split(Split, StringRef("+"), -1, false);
+
+  for (StringRef Feature : Split) {
+    if (Feature == "solana")
+      Features.push_back("+solana");
+    else
+      return false;
+  }
+  return true;
+}
+
+static bool
+getBPFArchFeaturesFromMarch(const Driver &D, StringRef March,
+                            const ArgList &Args,
+                            std::vector<StringRef> &Features) {
+  std::string MarchLowerCase = March.lower();
+  std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+");
+
+  return (Split.first == "bpfel" || Split.first == "bpfeb") &&
+    (Split.second.size() == 0 || DecodeBPFFeatures(D, Split.second, Features));
+}
+
+void bpf::getBPFTargetFeatures(const Driver &D, const ArgList &Args,
+                               std::vector<StringRef> &Features) {
+  Arg *A;
+  bool success = true;
+
+  if ((A = Args.getLastArg(options::OPT_target))) {
+    StringRef Target = A->getValue();
+    if (Target == "sbf") {
+      Features.push_back("+solana");
+    }
+  }
+
+  if ((A = Args.getLastArg(options::OPT_march_EQ)))
+    success = getBPFArchFeaturesFromMarch(D, A->getValue(), Args, Features);
+  if (!success)
+    D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
+}

clang/lib/Driver/ToolChains/Arch/BPF.h

@@ -0,0 +1,31 @@
+//===--- BPF.h - BPF-specific Tool Helpers ----------------------*- 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 LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_BPF_H
+#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_BPF_H
+
+#include "clang/Driver/Driver.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Option/Option.h"
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace driver {
+namespace tools {
+namespace bpf {
+
+void getBPFTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args,
+                          std::vector<llvm::StringRef> &Features);
+
+} // end namespace bpf
+} // namespace tools
+} // end namespace driver
+} // end namespace clang
+
+#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_BPF_H

clang/lib/Driver/ToolChains/CommonArgs.cpp

@@ -9,6 +9,7 @@
 #include "CommonArgs.h"
 #include "Arch/AArch64.h"
 #include "Arch/ARM.h"
+#include "Arch/BPF.h"
 #include "Arch/CSKY.h"
 #include "Arch/LoongArch.h"
 #include "Arch/M68k.h"
@@ -425,6 +426,7 @@ std::string tools::getCPUName(const Driver &D, const ArgList &Args,
 
   case llvm::Triple::bpfel:
   case llvm::Triple::bpfeb:
+  case llvm::Triple::sbf:
     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
       return A->getValue();
     return "";
@@ -500,6 +502,11 @@ void tools::getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
   case llvm::Triple::aarch64_be:
     aarch64::getAArch64TargetFeatures(D, Triple, Args, Features, ForAS);
     break;
+  case llvm::Triple::bpfeb:
+  case llvm::Triple::bpfel:
+  case llvm::Triple::sbf:
+    bpf::getBPFTargetFeatures(D, Args, Features);
+    break;
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     x86::getX86TargetFeatures(D, Triple, Args, Features);

clang/lib/Driver/ToolChains/Gnu.cpp

@@ -2917,6 +2917,7 @@ bool Generic_GCC::IsIntegratedAssemblerDefault() const {
   case llvm::Triple::r600:
   case llvm::Triple::riscv32:
   case llvm::Triple::riscv64:
+  case llvm::Triple::sbf:
   case llvm::Triple::sparc:
   case llvm::Triple::sparcel:
   case llvm::Triple::sparcv9:

clang/lib/Sema/SemaChecking.cpp

@@ -1999,6 +1999,7 @@ bool Sema::CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
     return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
   case llvm::Triple::bpfeb:
   case llvm::Triple::bpfel:
+  case llvm::Triple::sbf:
     return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
   case llvm::Triple::hexagon:
     return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);