mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
85657c9200
This feature adds an option from project.json and build options to disable libc unreachable statements in order to be able to implement one for yourself. Useful feature for bare metal developing. --------- Co-authored-by: Christoffer Lerno <christoffer@aegik.com>
213 lines
6.8 KiB
Plaintext
213 lines
6.8 KiB
Plaintext
// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
|
|
// Use of this source code is governed by the MIT license
|
|
// a copy of which can be found in the LICENSE_STDLIB file.
|
|
module std::core::env;
|
|
|
|
enum CompilerOptLevel
|
|
{
|
|
O0,
|
|
O1,
|
|
O2,
|
|
O3
|
|
}
|
|
|
|
enum MemoryEnvironment
|
|
{
|
|
NORMAL,
|
|
SMALL,
|
|
TINY,
|
|
NONE
|
|
}
|
|
|
|
enum OsType
|
|
{
|
|
UNKNOWN,
|
|
NONE,
|
|
ANANAS,
|
|
CLOUD_ABI,
|
|
DRAGON_FLY,
|
|
FREEBSD,
|
|
FUCHSIA,
|
|
IOS,
|
|
KFREEBSD,
|
|
LINUX,
|
|
PS3,
|
|
MACOS,
|
|
NETBSD,
|
|
OPENBSD,
|
|
SOLARIS,
|
|
WIN32,
|
|
HAIKU,
|
|
MINIX,
|
|
RTEMS,
|
|
NACL, // Native Client
|
|
CNK, // BG/P Compute-Node Kernel
|
|
AIX,
|
|
CUDA,
|
|
NVOPENCL,
|
|
AMDHSA,
|
|
PS4,
|
|
ELFIAMCU,
|
|
TVOS,
|
|
WATCHOS,
|
|
MESA3D,
|
|
CONTIKI,
|
|
AMDPAL,
|
|
HERMITCORE,
|
|
HURD,
|
|
WASI,
|
|
EMSCRIPTEN,
|
|
ANDROID,
|
|
}
|
|
|
|
enum ArchType
|
|
{
|
|
UNKNOWN,
|
|
ARM, // ARM (little endian): arm, armv.*, xscale
|
|
ARMB, // ARM (big endian): armeb
|
|
AARCH64, // AArch64 (little endian): aarch64
|
|
AARCH64_BE, // AArch64 (big endian): aarch64_be
|
|
AARCH64_32, // AArch64 (little endian) ILP32: aarch64_32
|
|
ARC, // ARC: Synopsys ARC
|
|
AVR, // AVR: Atmel AVR microcontroller
|
|
BPFEL, // eBPF or extended BPF or 64-bit BPF (little endian)
|
|
BPFEB, // eBPF or extended BPF or 64-bit BPF (big endian)
|
|
HEXAGON, // Hexagon: hexagon
|
|
MIPS, // MIPS: mips, mipsallegrex, mipsr6
|
|
MIPSEL, // MIPSEL: mipsel, mipsallegrexe, mipsr6el
|
|
MIPS64, // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
|
|
MIPS64EL, // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
|
|
MSP430, // MSP430: msp430
|
|
PPC, // PPC: powerpc
|
|
PPC64, // PPC64: powerpc64, ppu
|
|
PPC64LE, // PPC64LE: powerpc64le
|
|
R600, // R600: AMD GPUs HD2XXX - HD6XXX
|
|
AMDGCN, // AMDGCN: AMD GCN GPUs
|
|
RISCV32, // RISC-V (32-bit): riscv32
|
|
RISCV64, // RISC-V (64-bit): riscv64
|
|
SPARC, // Sparc: sparc
|
|
SPARCV9, // Sparcv9: Sparcv9
|
|
SPARCEL, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
|
|
SYSTEMZ, // SystemZ: s390x
|
|
TCE, // TCE (http://tce.cs.tut.fi/): tce
|
|
TCELE, // TCE little endian (http://tce.cs.tut.fi/): tcele
|
|
THUMB, // Thumb (little endian): thumb, thumbv.*
|
|
THUMBEB, // Thumb (big endian): thumbeb
|
|
X86, // X86: i[3-9]86
|
|
X86_64, // X86-64: amd64, x86_64
|
|
XCORE, // XCore: xcore
|
|
NVPTX, // NVPTX: 32-bit
|
|
NVPTX64, // NVPTX: 64-bit
|
|
LE32, // le32: generic little-endian 32-bit CPU (PNaCl)
|
|
LE64, // le64: generic little-endian 64-bit CPU (PNaCl)
|
|
AMDIL, // AMDIL
|
|
AMDIL64, // AMDIL with 64-bit pointers
|
|
HSAIL, // AMD HSAIL
|
|
HSAIL64, // AMD HSAIL with 64-bit pointers
|
|
SPIR, // SPIR: standard portable IR for OpenCL 32-bit version
|
|
SPIR64, // SPIR: standard portable IR for OpenCL 64-bit version
|
|
KALIMBA, // Kalimba: generic kalimba
|
|
SHAVE, // SHAVE: Movidius vector VLIW processors
|
|
LANAI, // Lanai: Lanai 32-bit
|
|
WASM32, // WebAssembly with 32-bit pointers
|
|
WASM64, // WebAssembly with 64-bit pointers
|
|
RSCRIPT32, // 32-bit RenderScript
|
|
RSCRIPT64, // 64-bit RenderScript
|
|
XTENSA, // Xtensa
|
|
}
|
|
|
|
const String COMPILER_BUILD_HASH = $$BUILD_HASH;
|
|
const String COMPILER_BUILD_DATE = $$BUILD_DATE;
|
|
const OsType OS_TYPE = OsType.from_ordinal($$OS_TYPE);
|
|
const ArchType ARCH_TYPE = ArchType.from_ordinal($$ARCH_TYPE);
|
|
const usz MAX_VECTOR_SIZE = $$MAX_VECTOR_SIZE;
|
|
const bool ARCH_32_BIT = $$REGISTER_SIZE == 32;
|
|
const bool ARCH_64_BIT = $$REGISTER_SIZE == 64;
|
|
const bool LIBC = $$COMPILER_LIBC_AVAILABLE;
|
|
const bool NO_LIBC = !LIBC && !CUSTOM_LIBC;
|
|
const bool CUSTOM_LIBC = $$CUSTOM_LIBC;
|
|
const CompilerOptLevel COMPILER_OPT_LEVEL = CompilerOptLevel.from_ordinal($$COMPILER_OPT_LEVEL);
|
|
const bool BIG_ENDIAN = $$PLATFORM_BIG_ENDIAN;
|
|
const bool I128_NATIVE_SUPPORT = $$PLATFORM_I128_SUPPORTED;
|
|
const bool F16_SUPPORT = $$PLATFORM_F16_SUPPORTED;
|
|
const bool F128_SUPPORT = $$PLATFORM_F128_SUPPORTED;
|
|
const REGISTER_SIZE = $$REGISTER_SIZE;
|
|
const bool COMPILER_SAFE_MODE = $$COMPILER_SAFE_MODE;
|
|
const bool DEBUG_SYMBOLS = $$DEBUG_SYMBOLS;
|
|
const bool BACKTRACE = $$BACKTRACE;
|
|
const usz LLVM_VERSION = $$LLVM_VERSION;
|
|
const bool BENCHMARKING = $$BENCHMARKING;
|
|
const bool TESTING = $$TESTING;
|
|
const bool PANIC_MSG = $$PANIC_MSG;
|
|
const MemoryEnvironment MEMORY_ENV = MemoryEnvironment.from_ordinal($$MEMORY_ENVIRONMENT);
|
|
const bool TRACK_MEMORY = DEBUG_SYMBOLS && (COMPILER_SAFE_MODE || TESTING);
|
|
const bool X86_64 = ARCH_TYPE == X86_64;
|
|
const bool X86 = ARCH_TYPE == X86;
|
|
const bool AARCH64 = ARCH_TYPE == AARCH64;
|
|
const bool NATIVE_STACKTRACE = LINUX || DARWIN || OPENBSD || WIN32;
|
|
const bool LINUX = LIBC && OS_TYPE == LINUX;
|
|
const bool DARWIN = LIBC && os_is_darwin();
|
|
const bool WIN32 = LIBC && OS_TYPE == WIN32;
|
|
const bool POSIX = LIBC && os_is_posix();
|
|
const bool OPENBSD = LIBC && OS_TYPE == OPENBSD;
|
|
const bool FREEBSD = LIBC && OS_TYPE == FREEBSD;
|
|
const bool NETBSD = LIBC && OS_TYPE == NETBSD;
|
|
const bool BSD_FAMILY = env::FREEBSD || env::OPENBSD || env::NETBSD;
|
|
const bool WASI = LIBC && OS_TYPE == WASI;
|
|
const bool ANDROID = LIBC && OS_TYPE == ANDROID;
|
|
const bool WASM_NOLIBC @builtin @deprecated("Use 'FREESTANDING_WASM' instead") = !LIBC && ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
|
|
const bool FREESTANDING_PE32 = NO_LIBC && OS_TYPE == WIN32;
|
|
const bool FREESTANDING_MACHO = NO_LIBC && OS_TYPE == MACOS;
|
|
const bool FREESTANDING_ELF = NO_LIBC && !env::FREESTANDING_PE32 && !env::FREESTANDING_MACHO && !env::FREESTANDING_WASM;
|
|
const bool FREESTANDING_WASM = NO_LIBC && (ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64);
|
|
const bool FREESTANDING = env::FREESTANDING_PE32 || env::FREESTANDING_MACHO || env::FREESTANDING_ELF || env::FREESTANDING_WASM;
|
|
const bool ADDRESS_SANITIZER = $$ADDRESS_SANITIZER;
|
|
const bool MEMORY_SANITIZER = $$MEMORY_SANITIZER;
|
|
const bool THREAD_SANITIZER = $$THREAD_SANITIZER;
|
|
const bool ANY_SANITIZER = ADDRESS_SANITIZER || MEMORY_SANITIZER || THREAD_SANITIZER;
|
|
const int LANGUAGE_DEV_VERSION = $$LANGUAGE_DEV_VERSION;
|
|
const bool HAS_NATIVE_ERRNO = env::LINUX || env::ANDROID || env::OPENBSD || env::DARWIN || env::WIN32;
|
|
|
|
macro bool os_is_darwin() @const
|
|
{
|
|
$switch OS_TYPE:
|
|
$case IOS:
|
|
$case MACOS:
|
|
$case TVOS:
|
|
$case WATCHOS:
|
|
return true;
|
|
$default:
|
|
return false;
|
|
$endswitch
|
|
}
|
|
|
|
macro bool os_is_posix() @const
|
|
{
|
|
$switch OS_TYPE:
|
|
$case IOS:
|
|
$case MACOS:
|
|
$case NETBSD:
|
|
$case LINUX:
|
|
$case KFREEBSD:
|
|
$case FREEBSD:
|
|
$case OPENBSD:
|
|
$case SOLARIS:
|
|
$case TVOS:
|
|
$case WATCHOS:
|
|
$case ANDROID:
|
|
return true;
|
|
$case WIN32:
|
|
$case WASI:
|
|
$case EMSCRIPTEN:
|
|
return false;
|
|
$default:
|
|
$echo("Assuming non-Posix environment");
|
|
return false;
|
|
$endswitch
|
|
}
|
|
const String[] AUTHORS = $$AUTHORS;
|
|
const String[] AUTHOR_EMAILS = $$AUTHOR_EMAILS;
|
|
const String PROJECT_VERSION = $$PROJECT_VERSION;
|
|
const BUILTIN_EXPECT_IS_DISABLED = $feature(DISABLE_BUILTIN_EXPECT);
|
|
const BUILTIN_PREFETCH_IS_DISABLED = $feature(DISABLE_BUILTIN_PREFETCH);
|