Assembly language support

Author: AJIOB

.github/workflows/integration-tests.yml

@@ -556,7 +556,7 @@ jobs:
       - name: Chmod for binary
         run: chmod +x ${SCCACHE_PATH}
 
-      - name: Test
+      - name: Test C/C++
         run: |
           export CXX="${SCCACHE_PATH} clang++"
           $CXX -c `pwd`/tests/test_clang_multicall.c
@@ -576,6 +576,16 @@ jobs:
 
           ${SCCACHE_PATH} --show-stats | grep -e "Cache hits\s*[1-9]"
 
+      - name: Test ASM
+        run: |
+          export ASM="${SCCACHE_PATH} clang"
+          $ASM -c `pwd`/tests/test_intel_asm.s
+
+      - name: Test ASM with preprocessor
+        run: |
+          export ASM="${SCCACHE_PATH} clang"
+          $ASM -c `pwd`/tests/test_intel_asm_to_preproc.S
+
   hip:
     # Probably wouldn't matter anyway since we run in a container, but staying
     # close to the version is better than not.
@@ -699,7 +709,7 @@ jobs:
       - name: Chmod for binary
         run: chmod +x ${SCCACHE_PATH}
 
-      - name: Test
+      - name: Test C/C++
         run: |
           export CXX="${SCCACHE_PATH} g++"
           $CXX -c `pwd`/tests/test_clang_multicall.c
@@ -719,6 +729,16 @@ jobs:
 
           ${SCCACHE_PATH} --show-stats | grep -e "Cache hits\s*[1-9]"
 
+      - name: Test ASM
+        run: |
+          export ASM="${SCCACHE_PATH} gcc"
+          $ASM -c `pwd`/tests/test_intel_asm.s
+
+      - name: Test ASM with preprocessor
+        run: |
+          export ASM="${SCCACHE_PATH} gcc"
+          $ASM -c `pwd`/tests/test_intel_asm_to_preproc.S
+
   autotools:
     runs-on: ubuntu-24.04
     needs: build

README.md

@@ -12,7 +12,7 @@ sccache - Shared Compilation Cache
 
 sccache is a [ccache](https://ccache.dev/)-like compiler caching tool. It is used as a compiler wrapper and avoids compilation when possible, storing cached results either on [local disk](docs/Local.md) or in one of [several cloud storage backends](#storage-options).
 
-sccache includes support for caching the compilation of C/C++ code, [Rust](docs/Rust.md), as well as NVIDIA's CUDA using [nvcc](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html), and [clang](https://llvm.org/docs/CompileCudaWithLLVM.html).
+sccache includes support for caching the compilation of Assembler, C/C++ code, [Rust](docs/Rust.md), as well as NVIDIA's CUDA using [nvcc](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html), and [clang](https://llvm.org/docs/CompileCudaWithLLVM.html), [AMD's ROCm HIP](https://rocm.docs.amd.com/projects/HIP/en/latest/index.html).
 
 sccache also provides [icecream](https://github.com/icecc/icecream)-style distributed compilation (automatic packaging of local toolchains) for all supported compilers (including Rust). The distributed compilation system includes several security features that icecream lacks such as authentication, transport layer encryption, and sandboxed compiler execution on build servers. See [the distributed quickstart](docs/DistributedQuickstart.md) guide for more information.
 
@@ -157,7 +157,7 @@ export RUSTC_WRAPPER=/path/to/sccache
 cargo build
 ```
 
-sccache supports gcc, clang, MSVC, rustc, [NVCC](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html), [NVC++](https://docs.nvidia.com/hpc-sdk//compilers/hpc-compilers-user-guide/index.html), and [Wind River's diab compiler](https://www.windriver.com/products/development-tools/#diab_compiler). Both gcc and msvc support Response Files, read more about their implementation [here](docs/ResponseFiles.md).
+sccache supports gcc, clang, MSVC, rustc, [NVCC](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html), [NVC++](https://docs.nvidia.com/hpc-sdk//compilers/hpc-compilers-user-guide/index.html), [hipcc](https://rocm.docs.amd.com/projects/HIP/en/latest/index.html), and [Wind River's diab compiler](https://www.windriver.com/products/development-tools/#diab_compiler). Both gcc and msvc support Response Files, read more about their implementation [here](docs/ResponseFiles.md).
 
 If you don't [specify otherwise](#storage-options), sccache will use a local disk cache.
 

src/compiler/c.rs

@@ -1657,6 +1657,10 @@ mod test {
             assert_eq!(actual, Some(expected));
         }
 
+        t("s", Language::Assembler);
+        t("S", Language::AssemblerToPreprocess);
+        t("sx", Language::AssemblerToPreprocess);
+
         t("c", Language::C);
 
         t("i", Language::CPreprocessed);

src/compiler/clang.rs

@@ -127,7 +127,8 @@ impl CCompilerImpl for Clang {
         };
 
         // Clang 14 and later support -fminimize-whitespace, which normalizes away non-semantic whitespace which in turn increases cache hit rate.
-        if self.is_minversion(14) {
+        // '-fminimize-whitespace' invalid for input of type assembler-with-cpp
+        if self.is_minversion(14) && parsed_args.language != Language::AssemblerToPreprocess {
             ignorable_whitespace_flags.push("-fminimize-whitespace".to_string());
         }
 

src/compiler/compiler.rs

@@ -214,6 +214,8 @@ pub enum CompilerKind {
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum Language {
+    AssemblerToPreprocess,
+    Assembler,
     C,
     Cxx,
     GenericHeader,
@@ -238,6 +240,8 @@ impl Language {
     pub fn from_file_name(file: &Path) -> Option<Self> {
         match file.extension().and_then(|e| e.to_str()) {
             // gcc: https://gcc.gnu.org/onlinedocs/gcc/Overall-Options.html
+            Some("s") => Some(Language::Assembler),
+            Some("S") | Some("sx") => Some(Language::AssemblerToPreprocess),
             Some("c") => Some(Language::C),
             // Could be C or C++
             Some("h") => Some(Language::GenericHeader),
@@ -266,6 +270,8 @@ impl Language {
 
     pub fn as_str(self) -> &'static str {
         match self {
+            Language::AssemblerToPreprocess => "assemblerToPreprocess",
+            Language::Assembler => "assembler",
             Language::C => "c",
             Language::CHeader => "cHeader",
             Language::CPreprocessed => "cPreprocessed",
@@ -289,7 +295,8 @@ impl Language {
     pub fn needs_c_preprocessing(self) -> bool {
         !matches!(
             self,
-            Language::CPreprocessed
+            Language::Assembler
+                | Language::CPreprocessed
                 | Language::CxxPreprocessed
                 | Language::ObjectiveCPreprocessed
                 | Language::ObjectiveCxxPreprocessed
@@ -300,6 +307,8 @@ impl Language {
     /// Common implementation for GCC and Clang language argument mapping
     fn to_compiler_arg(self, cuda_arg: &'static str) -> Option<&'static str> {
         match self {
+            Language::AssemblerToPreprocess => Some("assembler-with-cpp"),
+            Language::Assembler => Some("assembler"),
             Language::C => Some("c"),
             Language::CHeader => Some("c-header"),
             Language::CPreprocessed => Some("cpp-output"),
@@ -337,6 +346,7 @@ impl Language {
 impl CompilerKind {
     pub fn lang_kind(&self, lang: &Language) -> String {
         match lang {
+            Language::AssemblerToPreprocess | Language::Assembler => "Assembler",
             Language::C
             | Language::CHeader
             | Language::CPreprocessed

src/compiler/gcc.rs

@@ -404,6 +404,8 @@ where
             | Some(Unhashed(_)) => {}
             Some(Language(lang)) => {
                 language = match lang.to_string_lossy().as_ref() {
+                    "assembler" => Some(Language::Assembler),
+                    "assembler-with-cpp" => Some(Language::AssemblerToPreprocess),
                     "c" => Some(Language::C),
                     "c-header" => Some(Language::CHeader),
                     "c++" => Some(Language::Cxx),

tests/test_intel_asm.s

@@ -0,0 +1,31 @@
+.data
+
+hello_str:
+    .string "Hello, world!\n"
+
+
+    .set hello_str_length, . - hello_str - 1
+
+.text
+
+.globl  main
+
+.type   main, @function
+
+
+main:
+    movl    $4, %eax
+
+    movl    $1, %ebx
+
+    movl    $hello_str, %ecx
+
+    movl    $hello_str_length, %edx
+
+    int     $0x80
+
+    movl    $1, %eax
+    movl    $0, %ebx
+    int     $0x80
+
+    .size   main, . - main

tests/test_intel_asm_to_preproc.S

@@ -0,0 +1,31 @@
+.data
+
+hello_str:
+    .string "Hello, world!\n"
+
+
+    .set hello_str_length, . - hello_str - 1
+
+.text
+
+.globl  main
+
+.type   main, @function
+
+
+main:
+    movl    $4, %eax
+
+    movl    $1, %ebx
+
+    movl    $hello_str, %ecx
+
+    movl    $hello_str_length, %edx
+
+    int     $0x80
+
+    movl    $1, %eax
+    movl    $0, %ebx
+    int     $0x80
+
+    .size   main, . - main