Add some Xtensa targets

ESP32, ESP32s2, ESP8266 and a generic Xtensa target.

Author: MabezDev

compiler/rustc_target/src/spec/mod.rs

@@ -882,6 +882,11 @@ supported_targets! {
 
     ("nvptx64-nvidia-cuda", nvptx64_nvidia_cuda),
 
+    ("xtensa-esp32-none-elf", xtensa_esp32_none_elf),
+    ("xtensa-esp32s2-none-elf", xtensa_esp32s2_none_elf),
+    ("xtensa-esp8266-none-elf", xtensa_esp8266_none_elf),
+    ("xtensa-none-elf", xtensa_none_elf),
+
     ("i686-wrs-vxworks", i686_wrs_vxworks),
     ("x86_64-wrs-vxworks", x86_64_wrs_vxworks),
     ("armv7-wrs-vxworks-eabihf", armv7_wrs_vxworks_eabihf),

compiler/rustc_target/src/spec/xtensa_esp32_none_elf.rs

@@ -0,0 +1,50 @@
+use crate::spec::{abi::Abi, LinkerFlavor, PanicStrategy, Target, TargetOptions, RelocModel};
+use crate::abi::Endian;
+
+pub fn target() -> Target {
+    Target {
+        llvm_target: "xtensa-none-elf".to_string(),
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32".to_string(),
+        arch: "xtensa".to_string(),
+        
+        options: TargetOptions {
+            endian: Endian::Little,
+            c_int_width: "32".to_string(),
+            os: "none".to_string(),
+            env: String::new(),
+            vendor: String::new(),
+            linker_flavor: LinkerFlavor::Gcc,
+
+            executables: true,
+            cpu: "esp32".to_string(),
+            linker: Some("xtensa-esp32-elf-gcc".to_string()),
+
+            max_atomic_width: Some(32),
+
+            // Because these devices have very little resources having an
+            // unwinder is too onerous so we default to "abort" because the
+            // "unwind" strategy is very rare.
+            panic_strategy: PanicStrategy::Abort,
+
+            // Similarly, one almost always never wants to use relocatable
+            // code because of the extra costs it involves.
+            relocation_model: RelocModel::Static,
+
+            emit_debug_gdb_scripts: false,
+
+            unsupported_abis: vec![
+                Abi::Stdcall { unwind: false },
+                Abi::Stdcall { unwind: true },
+                Abi::Fastcall,
+                Abi::Vectorcall,
+                Abi::Thiscall { unwind: false },
+                Abi::Thiscall { unwind: true },
+                Abi::Win64,
+                Abi::SysV64,
+            ],
+
+            ..Default::default()
+        },
+    }
+}

compiler/rustc_target/src/spec/xtensa_esp32s2_none_elf.rs

@@ -0,0 +1,50 @@
+use crate::spec::{abi::Abi, LinkerFlavor, PanicStrategy, Target, TargetOptions, RelocModel};
+use crate::abi::Endian;
+
+pub fn target() -> Target {
+    Target {
+        llvm_target: "xtensa-none-elf".to_string(),
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32".to_string(),
+        arch: "xtensa".to_string(),
+        
+        options: TargetOptions {
+            endian: Endian::Little,
+            c_int_width: "32".to_string(),
+            os: "none".to_string(),
+            env: String::new(),
+            vendor: String::new(),
+            linker_flavor: LinkerFlavor::Gcc,
+
+            executables: true,
+            cpu: "esp32-s2".to_string(),
+            linker: Some("xtensa-esp32s2-elf-gcc".to_string()),
+
+            max_atomic_width: Some(32),
+
+            // Because these devices have very little resources having an
+            // unwinder is too onerous so we default to "abort" because the
+            // "unwind" strategy is very rare.
+            panic_strategy: PanicStrategy::Abort,
+
+            // Similarly, one almost always never wants to use relocatable
+            // code because of the extra costs it involves.
+            relocation_model: RelocModel::Static,
+
+            emit_debug_gdb_scripts: false,
+
+            unsupported_abis: vec![
+                Abi::Stdcall { unwind: false },
+                Abi::Stdcall { unwind: true },
+                Abi::Fastcall,
+                Abi::Vectorcall,
+                Abi::Thiscall { unwind: false },
+                Abi::Thiscall { unwind: true },
+                Abi::Win64,
+                Abi::SysV64,
+            ],
+
+            ..Default::default()
+        },
+    }
+}

compiler/rustc_target/src/spec/xtensa_esp8266_none_elf.rs

@@ -0,0 +1,50 @@
+use crate::spec::{abi::Abi, LinkerFlavor, PanicStrategy, Target, TargetOptions, RelocModel};
+use crate::abi::Endian;
+
+pub fn target() -> Target {
+    Target {
+        llvm_target: "xtensa-none-elf".to_string(),
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32".to_string(),
+        arch: "xtensa".to_string(),
+        
+        options: TargetOptions {
+            endian: Endian::Little,
+            c_int_width: "32".to_string(),
+            os: "none".to_string(),
+            env: String::new(),
+            vendor: String::new(),
+            linker_flavor: LinkerFlavor::Gcc,
+
+            executables: true,
+            cpu: "esp8266".to_string(),
+            linker: Some("xtensa-lx106-elf-gcc".to_string()),
+
+            max_atomic_width: Some(32),
+
+            // Because these devices have very little resources having an
+            // unwinder is too onerous so we default to "abort" because the
+            // "unwind" strategy is very rare.
+            panic_strategy: PanicStrategy::Abort,
+
+            // Similarly, one almost always never wants to use relocatable
+            // code because of the extra costs it involves.
+            relocation_model: RelocModel::Static,
+
+            emit_debug_gdb_scripts: false,
+
+            unsupported_abis: vec![
+                Abi::Stdcall { unwind: false },
+                Abi::Stdcall { unwind: true },
+                Abi::Fastcall,
+                Abi::Vectorcall,
+                Abi::Thiscall { unwind: false },
+                Abi::Thiscall { unwind: true },
+                Abi::Win64,
+                Abi::SysV64,
+            ],
+
+            ..Default::default()
+        },
+    }
+}

compiler/rustc_target/src/spec/xtensa_none_elf.rs

@@ -0,0 +1,49 @@
+use crate::spec::{abi::Abi, LinkerFlavor, PanicStrategy, Target, TargetOptions, RelocModel};
+use crate::abi::Endian;
+
+pub fn target() -> Target {
+    Target {
+        llvm_target: "xtensa-none-elf".to_string(),
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32".to_string(),
+        arch: "xtensa".to_string(),
+        
+        options: TargetOptions {
+            endian: Endian::Little,
+            c_int_width: "32".to_string(),
+            os: "none".to_string(),
+            env: String::new(),
+            vendor: String::new(),
+            linker_flavor: LinkerFlavor::Gcc,
+
+            executables: true,
+            linker: Some("xtensa-esp32-elf-gcc".to_string()),
+
+            max_atomic_width: Some(32),
+
+            // Because these devices have very little resources having an
+            // unwinder is too onerous so we default to "abort" because the
+            // "unwind" strategy is very rare.
+            panic_strategy: PanicStrategy::Abort,
+
+            // Similarly, one almost always never wants to use relocatable
+            // code because of the extra costs it involves.
+            relocation_model: RelocModel::Static,
+
+            emit_debug_gdb_scripts: false,
+
+            unsupported_abis: vec![
+                Abi::Stdcall { unwind: false },
+                Abi::Stdcall { unwind: true },
+                Abi::Fastcall,
+                Abi::Vectorcall,
+                Abi::Thiscall { unwind: false },
+                Abi::Thiscall { unwind: true },
+                Abi::Win64,
+                Abi::SysV64,
+            ],
+
+            ..Default::default()
+        },
+    }
+}