diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index dc4240b04..ede32f093 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -52,7 +52,7 @@ jobs: usesh: true copyback: false prepare: | - pkg install -y gmake git bash python3 libxml2 llvm17 + pkg install -y gmake git bash python3 libxml2 llvm18 run: | # `set -e` is needed for test failures to register. https://github.com/vmactions/freebsd-vm/issues/72 set -e -x @@ -87,20 +87,20 @@ jobs: run: | wget https://apt.llvm.org/llvm.sh chmod +x llvm.sh - sudo ./llvm.sh 17 - echo "/usr/lib/llvm-17/bin" >> $GITHUB_PATH + sudo ./llvm.sh 20 + echo "/usr/lib/llvm-20/bin" >> $GITHUB_PATH - name: Download LLVM (MacOS Intel) if: matrix.os == 'macos-13' run: | - brew install llvm@17 lua@5.4 - echo "/usr/local/opt/llvm@17/bin" >> $GITHUB_PATH + brew install llvm@18 lua@5.4 + echo "/usr/local/opt/llvm@18/bin" >> $GITHUB_PATH - name: Download LLVM (MacOS ARM) if: matrix.os == 'macos-14' run: | - brew install llvm@17 wasmtime lua@5.4 - echo "/opt/homebrew/opt/llvm@17/bin" >> $GITHUB_PATH + brew install llvm@18 wasmtime lua@5.4 + echo "/opt/homebrew/opt/llvm@18/bin" >> $GITHUB_PATH - name: Build Odin run: ./build_odin.sh release @@ -167,7 +167,7 @@ jobs: - name: Run demo on WASI WASM32 run: | - ./odin build examples/demo -target:wasi_wasm32 -vet -strict-style -disallow-do -out:demo.wasm + ./odin build examples/demo -target:wasi_wasm32 -vet -strict-style -disallow-do -out:demo wasmtime ./demo.wasm if: matrix.os == 'macos-14' diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 314711efb..80b2a72af 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -53,8 +53,8 @@ jobs: - name: (Linux) Download LLVM run: | apk add --no-cache \ - musl-dev llvm18-dev clang18 git mold lz4 \ - libxml2-static llvm18-static zlib-static zstd-static \ + musl-dev llvm20-dev clang20 git mold lz4 \ + libxml2-static llvm20-static zlib-static zstd-static \ make shell: alpine.sh --root {0} - name: build odin diff --git a/LLVM-C.dll b/LLVM-C.dll index ee03a2acd..b2f22ba8e 100644 Binary files a/LLVM-C.dll and b/LLVM-C.dll differ diff --git a/bin/lld-link.exe b/bin/lld-link.exe index da6527264..ec739e0fd 100644 Binary files a/bin/lld-link.exe and b/bin/lld-link.exe differ diff --git a/bin/llvm/windows/LLVM-C.lib b/bin/llvm/windows/LLVM-C.lib index 0e5b6c624..6230de057 100644 Binary files a/bin/llvm/windows/LLVM-C.lib and b/bin/llvm/windows/LLVM-C.lib differ diff --git a/bin/llvm/windows/clang_rt.asan-x86_64.lib b/bin/llvm/windows/clang_rt.asan-x86_64.lib index 0b209dc8d..d7dfcbb1c 100644 Binary files a/bin/llvm/windows/clang_rt.asan-x86_64.lib and b/bin/llvm/windows/clang_rt.asan-x86_64.lib differ diff --git a/bin/wasm-ld.exe b/bin/wasm-ld.exe index da6527264..ec739e0fd 100644 Binary files a/bin/wasm-ld.exe and b/bin/wasm-ld.exe differ diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin index 14d722689..e0c89ac85 100644 --- a/core/fmt/fmt.odin +++ b/core/fmt/fmt.odin @@ -116,11 +116,12 @@ register_user_formatter :: proc(id: typeid, formatter: User_Formatter) -> Regist } // Creates a formatted string // -// *Allocates Using Context's Allocator* +// *Allocates Using Provided Allocator* // // Inputs: // - args: A variadic list of arguments to be formatted. // - sep: An optional separator string (default is a single space). +// - allocator: (default: context.allocator) // // Returns: A formatted string. // @@ -132,11 +133,12 @@ aprint :: proc(args: ..any, sep := " ", allocator := context.allocator) -> strin } // Creates a formatted string with a newline character at the end // -// *Allocates Using Context's Allocator* +// *Allocates Using Provided Allocator* // // Inputs: // - args: A variadic list of arguments to be formatted. // - sep: An optional separator string (default is a single space). +// - allocator: (default: context.allocator) // // Returns: A formatted string with a newline character at the end. // @@ -148,11 +150,12 @@ aprintln :: proc(args: ..any, sep := " ", allocator := context.allocator) -> str } // Creates a formatted string using a format string and arguments // -// *Allocates Using Context's Allocator* +// *Allocates Using Provided Allocator* // // Inputs: // - fmt: A format string with placeholders for the provided arguments. // - args: A variadic list of arguments to be formatted. +// - allocator: (default: context.allocator) // - newline: Whether the string should end with a newline. (See `aprintfln`.) // // Returns: A formatted string. The returned string must be freed accordingly. @@ -165,11 +168,12 @@ aprintf :: proc(fmt: string, args: ..any, allocator := context.allocator, newlin } // Creates a formatted string using a format string and arguments, followed by a newline. // -// *Allocates Using Context's Allocator* +// *Allocates Using Provided Allocator* // // Inputs: // - fmt: A format string with placeholders for the provided arguments. // - args: A variadic list of arguments to be formatted. +// - allocator: (default: context.allocator) // // Returns: A formatted string. The returned string must be freed accordingly. // @@ -359,11 +363,12 @@ panicf :: proc(fmt: string, args: ..any, loc := #caller_location) -> ! { // Creates a formatted C string // -// *Allocates Using Context's Allocator* +// *Allocates Using Provided Allocator* // // Inputs: // - args: A variadic list of arguments to be formatted. // - sep: An optional separator string (default is a single space). +// - allocator: (default: context.allocator) // // Returns: A formatted C string. // @@ -379,11 +384,12 @@ caprint :: proc(args: ..any, sep := " ", allocator := context.allocator) -> cstr // Creates a formatted C string // -// *Allocates Using Context's Allocator* +// *Allocates Using Provided Allocator* // // Inputs: // - format: A format string with placeholders for the provided arguments // - args: A variadic list of arguments to be formatted +// - allocator: (default: context.allocator) // - newline: Whether the string should end with a newline. (See `caprintfln`.) // // Returns: A formatted C string @@ -399,11 +405,12 @@ caprintf :: proc(format: string, args: ..any, allocator := context.allocator, ne } // Creates a formatted C string, followed by a newline. // -// *Allocates Using Context's Allocator* +// *Allocates Using Provided Allocator* // // Inputs: // - format: A format string with placeholders for the provided arguments // - args: A variadic list of arguments to be formatted +// - allocator: (default: context.allocator) // // Returns: A formatted C string // diff --git a/core/sys/linux/sys.odin b/core/sys/linux/sys.odin index 532c1ff5f..5fc4a0efa 100644 --- a/core/sys/linux/sys.odin +++ b/core/sys/linux/sys.odin @@ -212,7 +212,7 @@ rt_sigreturn :: proc "c" () -> ! { /* Alter an action taken by a process. */ -rt_sigaction :: proc "contextless" (sig: Signal, sigaction: ^Sig_Action($T), old_sigaction: ^Sig_Action) -> Errno { +rt_sigaction :: proc "contextless" (sig: Signal, sigaction: ^Sig_Action($T), old_sigaction: ^Sig_Action($U)) -> Errno { // NOTE(jason): It appears that the restorer is required for i386 and amd64 when ODIN_ARCH == .i386 || ODIN_ARCH == .amd64 { sigaction.flags += {.RESTORER} diff --git a/core/sys/linux/syscall_arm64.odin b/core/sys/linux/syscall_arm64.odin index da8eb45da..6f1c93f83 100644 --- a/core/sys/linux/syscall_arm64.odin +++ b/core/sys/linux/syscall_arm64.odin @@ -317,5 +317,18 @@ SYS_futex_waitv :: uintptr(449) SYS_set_mempolicy_home_node :: uintptr(450) SYS_cachestat :: uintptr(451) SYS_fchmodat2 :: uintptr(452) - +SYS_map_shadow_stack :: uintptr(453) +SYS_futex_wake :: uintptr(454) +SYS_futex_wait :: uintptr(455) +SYS_futex_requeue :: uintptr(456) +SYS_statmount :: uintptr(457) +SYS_listmount :: uintptr(458) +SYS_lsm_get_self_attr :: uintptr(459) +SYS_lsm_set_self_attr :: uintptr(460) +SYS_lsm_list_modules :: uintptr(461) +SYS_mseal :: uintptr(462) +SYS_setxattrat :: uintptr(463) +SYS_getxattrat :: uintptr(464) +SYS_listxattrat :: uintptr(465) +SYS_removexattrat :: uintptr(466) diff --git a/core/sys/wasm/js/events.odin b/core/sys/wasm/js/events.odin index ffa3a1202..f55ee8b90 100644 --- a/core/sys/wasm/js/events.odin +++ b/core/sys/wasm/js/events.odin @@ -189,7 +189,7 @@ Key_Location :: enum u8 { KEYBOARD_MAX_KEY_SIZE :: 32 KEYBOARD_MAX_CODE_SIZE :: 32 -GAMEPAD_MAX_ID_SIZE :: 64 +GAMEPAD_MAX_ID_SIZE :: 96 GAMEPAD_MAX_MAPPING_SIZE :: 64 GAMEPAD_MAX_BUTTONS :: 64 @@ -239,6 +239,12 @@ Gamepad_State :: struct { _mapping_buf: [GAMEPAD_MAX_MAPPING_SIZE]byte `fmt:"-"`, } +Pointer_Type :: enum u8 { + Mouse, + Pen, + Touch, +} + Event :: struct { kind: Event_Kind, target_kind: Event_Target_Kind, @@ -275,6 +281,8 @@ Event :: struct { repeat: bool, + char: rune, + _key_len: int `fmt:"-"`, _code_len: int `fmt:"-"`, _key_buf: [KEYBOARD_MAX_KEY_SIZE]byte `fmt:"-"`, @@ -295,6 +303,21 @@ Event :: struct { button: i16, buttons: bit_set[0..<16; u16], + + pointer: struct { + altitude_angle: f64, + azimuth_angle: f64, + persistent_device_id: int, + pointer_id: int, + width: int, + height: int, + pressure: f64, + tangential_pressure: f64, + tilt: [2]f64, + twist: f64, + pointer_type: Pointer_Type, + is_primary: bool, + }, }, gamepad: Gamepad_State, @@ -384,7 +407,14 @@ get_gamepad_state :: proc "contextless" (index: int, s: ^Gamepad_State) -> bool if s == nil { return false } - return _get_gamepad_state(index, s) + + if !_get_gamepad_state(index, s) { + return false + } + + s.id = string(s._id_buf[:s._id_len]) + s.mapping = string(s._mapping_buf[:s._mapping_len]) + return true } @@ -415,4 +445,4 @@ do_event_callback :: proc(user_data: rawptr, callback: proc(e: Event)) { callback(event) } -} \ No newline at end of file +} diff --git a/core/sys/wasm/js/general.odin b/core/sys/wasm/js/general.odin index 4ed2ae298..22bb08e2b 100644 --- a/core/sys/wasm/js/general.odin +++ b/core/sys/wasm/js/general.odin @@ -9,4 +9,5 @@ foreign odin_env { abort :: proc() -> ! --- alert :: proc(msg: string) --- evaluate :: proc(str: string) --- -} \ No newline at end of file + open :: proc(url: string, name := "", specs := "") --- +} diff --git a/core/sys/wasm/js/odin.js b/core/sys/wasm/js/odin.js index 29227c526..4e3bb3c22 100644 --- a/core/sys/wasm/js/odin.js +++ b/core/sys/wasm/js/odin.js @@ -402,6 +402,9 @@ class WebGLInterface { BlendEquation: (mode) => { this.ctx.blendEquation(mode); }, + BlendEquationSeparate: (modeRGB, modeAlpha) => { + this.ctx.blendEquationSeparate(modeRGB, modeAlpha); + }, BlendFunc: (sfactor, dfactor) => { this.ctx.blendFunc(sfactor, dfactor); }, @@ -633,6 +636,13 @@ class WebGLInterface { GetParameter: (pname) => { return this.ctx.getParameter(pname); }, + GetParameter4i: (pname, v0, v1, v2, v3) => { + const i4 = this.ctx.getParameter(pname); + this.mem.storeI32(v0, i4[0]); + this.mem.storeI32(v1, i4[1]); + this.mem.storeI32(v2, i4[2]); + this.mem.storeI32(v3, i4[3]); + }, GetProgramParameter: (program, pname) => { return this.ctx.getProgramParameter(this.programs[program], pname) }, @@ -1421,6 +1431,13 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement, memory) { abort: () => { Module.abort() }, evaluate: (str_ptr, str_len) => { eval.call(null, wasmMemoryInterface.loadString(str_ptr, str_len)); }, + open: (url_ptr, url_len, name_ptr, name_len, specs_ptr, specs_len) => { + const url = wasmMemoryInterface.loadString(url_ptr, url_len); + const name = wasmMemoryInterface.loadString(name_ptr, name_len); + const specs = wasmMemoryInterface.loadString(specs_ptr, specs_len); + window.open(url, name, specs); + }, + // return a bigint to be converted to i64 time_now: () => BigInt(Date.now()), tick_now: () => performance.now(), @@ -1533,6 +1550,29 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement, memory) { wmi.storeI16(off(2), e.button); wmi.storeU16(off(2), e.buttons); + + if (e instanceof PointerEvent) { + wmi.storeF64(off(8), e.altitudeAngle); + wmi.storeF64(off(8), e.azimuthAngle); + wmi.storeInt(off(W), e.persistentDeviceId); + wmi.storeInt(off(W), e.pointerId); + wmi.storeInt(off(W), e.width); + wmi.storeInt(off(W), e.height); + wmi.storeF64(off(8), e.pressure); + wmi.storeF64(off(8), e.tangentialPressure); + wmi.storeF64(off(8), e.tiltX); + wmi.storeF64(off(8), e.tiltY); + wmi.storeF64(off(8), e.twist); + if (e.pointerType == "pen") { + wmi.storeU8(off(1), 1); + } else if (e.pointerType == "touch") { + wmi.storeU8(off(1), 2); + } else { + wmi.storeU8(off(1), 0); + } + wmi.storeU8(off(1), !!e.isPrimary); + } + } else if (e instanceof KeyboardEvent) { // Note: those strings are constructed // on the native side from buffers that @@ -1549,6 +1589,8 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement, memory) { wmi.storeU8(off(1), !!e.repeat); + wmi.storeI32(off(4), e.charCode); + wmi.storeInt(off(W, W), e.key.length) wmi.storeInt(off(W, W), e.code.length) wmi.storeString(off(32, 1), e.key); @@ -1588,10 +1630,24 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement, memory) { } } - wmi.storeInt(off(W, W), e.gamepad.id.length) - wmi.storeInt(off(W, W), e.gamepad.mapping.length) - wmi.storeString(off(64, 1), e.gamepad.id); - wmi.storeString(off(64, 1), e.gamepad.mapping); + let idLength = e.gamepad.id.length; + let id = e.gamepad.id; + if (idLength > 96) { + idLength = 96; + id = id.slice(0, 93) + '...'; + } + + let mappingLength = e.gamepad.mapping.length; + let mapping = e.gamepad.mapping; + if (mappingLength > 64) { + mappingLength = 61; + mapping = mapping.slice(0, 61) + '...'; + } + + wmi.storeInt(off(W, W), idLength); + wmi.storeInt(off(W, W), mappingLength); + wmi.storeString(off(96, 1), id); + wmi.storeString(off(64, 1), mapping); } }, @@ -1756,10 +1812,24 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement, memory) { } } - wmi.storeInt(off(W, W), gamepad.id.length) - wmi.storeInt(off(W, W), gamepad.mapping.length) - wmi.storeString(off(64, 1), gamepad.id); - wmi.storeString(off(64, 1), gamepad.mapping); + let idLength = gamepad.id.length; + let id = gamepad.id; + if (idLength > 96) { + idLength = 96; + id = id.slice(0, 93) + '...'; + } + + let mappingLength = gamepad.mapping.length; + let mapping = gamepad.mapping; + if (mappingLength > 64) { + mappingLength = 61; + mapping = mapping.slice(0, 61) + '...'; + } + + wmi.storeInt(off(W, W), idLength); + wmi.storeInt(off(W, W), mappingLength); + wmi.storeString(off(96, 1), id); + wmi.storeString(off(64, 1), mapping); return true; } diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 57e5f36b3..dd7b8576c 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -3670,6 +3670,11 @@ gb_internal bool check_transmute(CheckerContext *c, Ast *node, Operand *o, Type } gb_internal bool check_binary_array_expr(CheckerContext *c, Token op, Operand *x, Operand *y) { + if (is_type_array_like(x->type) || is_type_array_like(y->type)) { + if (op.kind == Token_CmpAnd || op.kind == Token_CmpOr) { + error(op, "Array programming is not allowed with the operator '%.*s'", LIT(op.string)); + } + } if (is_type_array(x->type) && !is_type_array(y->type)) { if (check_is_assignable_to(c, y, x->type)) { if (check_binary_op(c, x, op)) { @@ -4508,8 +4513,7 @@ gb_internal void convert_to_typed(CheckerContext *c, Operand *operand, Type *tar } else { switch (operand->type->Basic.kind) { case Basic_UntypedBool: - if (!is_type_boolean(target_type) && - !is_type_integer(target_type)) { + if (!is_type_boolean(target_type)) { operand->mode = Addressing_Invalid; convert_untyped_error(c, operand, target_type); return; diff --git a/src/llvm-c/Analysis.h b/src/llvm-c/Analysis.h index 6b93b5c3d..270b145a4 100644 --- a/src/llvm-c/Analysis.h +++ b/src/llvm-c/Analysis.h @@ -19,8 +19,8 @@ #ifndef LLVM_C_ANALYSIS_H #define LLVM_C_ANALYSIS_H -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/BitReader.h b/src/llvm-c/BitReader.h index 725f3fa84..088107468 100644 --- a/src/llvm-c/BitReader.h +++ b/src/llvm-c/BitReader.h @@ -19,8 +19,8 @@ #ifndef LLVM_C_BITREADER_H #define LLVM_C_BITREADER_H -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/BitWriter.h b/src/llvm-c/BitWriter.h index ba4a61afc..ea84b6593 100644 --- a/src/llvm-c/BitWriter.h +++ b/src/llvm-c/BitWriter.h @@ -19,8 +19,8 @@ #ifndef LLVM_C_BITWRITER_H #define LLVM_C_BITWRITER_H -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Comdat.h b/src/llvm-c/Comdat.h index 30df20799..8002bc058 100644 --- a/src/llvm-c/Comdat.h +++ b/src/llvm-c/Comdat.h @@ -14,8 +14,8 @@ #ifndef LLVM_C_COMDAT_H #define LLVM_C_COMDAT_H -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Config/llvm-config.h b/src/llvm-c/Config/llvm-config.h index e4edb83c5..8b77597c9 100644 --- a/src/llvm-c/Config/llvm-config.h +++ b/src/llvm-c/Config/llvm-config.h @@ -142,16 +142,16 @@ #define LLVM_USE_PERF 0 /* Major version of the LLVM API */ -#define LLVM_VERSION_MAJOR 18 +#define LLVM_VERSION_MAJOR 20 /* Minor version of the LLVM API */ #define LLVM_VERSION_MINOR 1 /* Patch version of the LLVM API */ -#define LLVM_VERSION_PATCH 8 +#define LLVM_VERSION_PATCH 0 /* LLVM version string */ -#define LLVM_VERSION_STRING "18.1.8" +#define LLVM_VERSION_STRING "20.1.0" /* Whether LLVM records statistics for use with GetStatistics(), * PrintStatistics() or PrintStatisticsJSON() diff --git a/src/llvm-c/Core.h b/src/llvm-c/Core.h index 25b8248fd..dc8ecf4fb 100644 --- a/src/llvm-c/Core.h +++ b/src/llvm-c/Core.h @@ -15,11 +15,11 @@ #ifndef LLVM_C_CORE_H #define LLVM_C_CORE_H -#include "Deprecated.h" -#include "ErrorHandling.h" -#include "ExternC.h" +#include "llvm-c/Deprecated.h" +#include "llvm-c/ErrorHandling.h" +#include "llvm-c/ExternC.h" -#include "Types.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN @@ -146,27 +146,27 @@ typedef enum { } LLVMOpcode; typedef enum { - LLVMVoidTypeKind, /**< type with no size */ - LLVMHalfTypeKind, /**< 16 bit floating point type */ - LLVMFloatTypeKind, /**< 32 bit floating point type */ - LLVMDoubleTypeKind, /**< 64 bit floating point type */ - LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */ - LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/ - LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */ - LLVMLabelTypeKind, /**< Labels */ - LLVMIntegerTypeKind, /**< Arbitrary bit width integers */ - LLVMFunctionTypeKind, /**< Functions */ - LLVMStructTypeKind, /**< Structures */ - LLVMArrayTypeKind, /**< Arrays */ - LLVMPointerTypeKind, /**< Pointers */ - LLVMVectorTypeKind, /**< Fixed width SIMD vector type */ - LLVMMetadataTypeKind, /**< Metadata */ - LLVMX86_MMXTypeKind, /**< X86 MMX */ - LLVMTokenTypeKind, /**< Tokens */ - LLVMScalableVectorTypeKind, /**< Scalable SIMD vector type */ - LLVMBFloatTypeKind, /**< 16 bit brain floating point type */ - LLVMX86_AMXTypeKind, /**< X86 AMX */ - LLVMTargetExtTypeKind, /**< Target extension type */ + LLVMVoidTypeKind = 0, /**< type with no size */ + LLVMHalfTypeKind = 1, /**< 16 bit floating point type */ + LLVMFloatTypeKind = 2, /**< 32 bit floating point type */ + LLVMDoubleTypeKind = 3, /**< 64 bit floating point type */ + LLVMX86_FP80TypeKind = 4, /**< 80 bit floating point type (X87) */ + LLVMFP128TypeKind = 5, /**< 128 bit floating point type (112-bit mantissa)*/ + LLVMPPC_FP128TypeKind = 6, /**< 128 bit floating point type (two 64-bits) */ + LLVMLabelTypeKind = 7, /**< Labels */ + LLVMIntegerTypeKind = 8, /**< Arbitrary bit width integers */ + LLVMFunctionTypeKind = 9, /**< Functions */ + LLVMStructTypeKind = 10, /**< Structures */ + LLVMArrayTypeKind = 11, /**< Arrays */ + LLVMPointerTypeKind = 12, /**< Pointers */ + LLVMVectorTypeKind = 13, /**< Fixed width SIMD vector type */ + LLVMMetadataTypeKind = 14, /**< Metadata */ + /* 15 previously used by LLVMX86_MMXTypeKind */ + LLVMTokenTypeKind = 16, /**< Tokens */ + LLVMScalableVectorTypeKind = 17, /**< Scalable SIMD vector type */ + LLVMBFloatTypeKind = 18, /**< 16 bit brain floating point type */ + LLVMX86_AMXTypeKind = 19, /**< X86 AMX */ + LLVMTargetExtTypeKind = 20, /**< Target extension type */ } LLVMTypeKind; typedef enum { @@ -286,6 +286,7 @@ typedef enum { LLVMInstructionValueKind, LLVMPoisonValueValueKind, LLVMConstantTargetNoneValueKind, + LLVMConstantPtrAuthValueKind, } LLVMValueKind; typedef enum { @@ -361,35 +362,42 @@ typedef enum { } LLVMAtomicOrdering; typedef enum { - LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */ - LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */ - LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */ - LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */ - LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */ - LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */ - LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */ - LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the - original using a signed comparison and return - the old one */ - LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the - original using a signed comparison and return - the old one */ - LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the - original using an unsigned comparison and return - the old one */ - LLVMAtomicRMWBinOpUMin, /**< Sets the value if it's greater than the - original using an unsigned comparison and return - the old one */ - LLVMAtomicRMWBinOpFAdd, /**< Add a floating point value and return the - old one */ - LLVMAtomicRMWBinOpFSub, /**< Subtract a floating point value and return the + LLVMAtomicRMWBinOpXchg, /**< Set the new value and return the one old */ + LLVMAtomicRMWBinOpAdd, /**< Add a value and return the old one */ + LLVMAtomicRMWBinOpSub, /**< Subtract a value and return the old one */ + LLVMAtomicRMWBinOpAnd, /**< And a value and return the old one */ + LLVMAtomicRMWBinOpNand, /**< Not-And a value and return the old one */ + LLVMAtomicRMWBinOpOr, /**< OR a value and return the old one */ + LLVMAtomicRMWBinOpXor, /**< Xor a value and return the old one */ + LLVMAtomicRMWBinOpMax, /**< Sets the value if it's greater than the + original using a signed comparison and return + the old one */ + LLVMAtomicRMWBinOpMin, /**< Sets the value if it's Smaller than the + original using a signed comparison and return + the old one */ + LLVMAtomicRMWBinOpUMax, /**< Sets the value if it's greater than the + original using an unsigned comparison and return + the old one */ + LLVMAtomicRMWBinOpUMin, /**< Sets the value if it's greater than the + original using an unsigned comparison and return + the old one */ + LLVMAtomicRMWBinOpFAdd, /**< Add a floating point value and return the old one */ - LLVMAtomicRMWBinOpFMax, /**< Sets the value if it's greater than the - original using an floating point comparison and - return the old one */ - LLVMAtomicRMWBinOpFMin, /**< Sets the value if it's smaller than the - original using an floating point comparison and - return the old one */ + LLVMAtomicRMWBinOpFSub, /**< Subtract a floating point value and return the + old one */ + LLVMAtomicRMWBinOpFMax, /**< Sets the value if it's greater than the + original using an floating point comparison and + return the old one */ + LLVMAtomicRMWBinOpFMin, /**< Sets the value if it's smaller than the + original using an floating point comparison and + return the old one */ + LLVMAtomicRMWBinOpUIncWrap, /**< Increments the value, wrapping back to zero + when incremented above input value */ + LLVMAtomicRMWBinOpUDecWrap, /**< Decrements the value, wrapping back to + the input value when decremented below zero */ + LLVMAtomicRMWBinOpUSubCond, /** #else diff --git a/src/llvm-c/Error.h b/src/llvm-c/Error.h index 00746c701..874bbcfe8 100644 --- a/src/llvm-c/Error.h +++ b/src/llvm-c/Error.h @@ -14,7 +14,7 @@ #ifndef LLVM_C_ERROR_H #define LLVM_C_ERROR_H -#include "ExternC.h" +#include "llvm-c/ExternC.h" LLVM_C_EXTERN_C_BEGIN @@ -51,6 +51,14 @@ LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err); */ void LLVMConsumeError(LLVMErrorRef Err); +/** + * Report a fatal error if Err is a failure value. + * + * This function can be used to wrap calls to fallible functions ONLY when it is + * known that the Error will always be a success value. + */ +void LLVMCantFail(LLVMErrorRef Err); + /** * Returns the given string's error message. This operation consumes the error, * and the given LLVMErrorRef value is not usable once this call returns. diff --git a/src/llvm-c/ErrorHandling.h b/src/llvm-c/ErrorHandling.h index 7f9b50a95..d9b9f2275 100644 --- a/src/llvm-c/ErrorHandling.h +++ b/src/llvm-c/ErrorHandling.h @@ -14,7 +14,7 @@ #ifndef LLVM_C_ERRORHANDLING_H #define LLVM_C_ERRORHANDLING_H -#include "ExternC.h" +#include "llvm-c/ExternC.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/ExecutionEngine.h b/src/llvm-c/ExecutionEngine.h index 8e72faefd..c5fc9bdb4 100644 --- a/src/llvm-c/ExecutionEngine.h +++ b/src/llvm-c/ExecutionEngine.h @@ -19,10 +19,10 @@ #ifndef LLVM_C_EXECUTIONENGINE_H #define LLVM_C_EXECUTIONENGINE_H -#include "ExternC.h" -#include "Target.h" -#include "TargetMachine.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Target.h" +#include "llvm-c/TargetMachine.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/IRReader.h b/src/llvm-c/IRReader.h index ec1110c7a..905b84fa5 100644 --- a/src/llvm-c/IRReader.h +++ b/src/llvm-c/IRReader.h @@ -14,8 +14,8 @@ #ifndef LLVM_C_IRREADER_H #define LLVM_C_IRREADER_H -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/LLJIT.h b/src/llvm-c/LLJIT.h index ee207e10e..a58c3b8bb 100644 --- a/src/llvm-c/LLJIT.h +++ b/src/llvm-c/LLJIT.h @@ -24,10 +24,10 @@ #ifndef LLVM_C_LLJIT_H #define LLVM_C_LLJIT_H -#include "Error.h" -#include "Orc.h" -#include "TargetMachine.h" -#include "Types.h" +#include "llvm-c/Error.h" +#include "llvm-c/Orc.h" +#include "llvm-c/TargetMachine.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/LLJITUtils.h b/src/llvm-c/LLJITUtils.h index 57ffedff8..940097432 100644 --- a/src/llvm-c/LLJITUtils.h +++ b/src/llvm-c/LLJITUtils.h @@ -26,7 +26,7 @@ #ifndef LLVM_C_LLJITUTILS_H #define LLVM_C_LLJITUTILS_H -#include "LLJIT.h" +#include "llvm-c/LLJIT.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Linker.h b/src/llvm-c/Linker.h index 463a2cff9..acff5d5e2 100644 --- a/src/llvm-c/Linker.h +++ b/src/llvm-c/Linker.h @@ -14,8 +14,8 @@ #ifndef LLVM_C_LINKER_H #define LLVM_C_LINKER_H -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Object.h b/src/llvm-c/Object.h index 1948c3c34..2f39179c1 100644 --- a/src/llvm-c/Object.h +++ b/src/llvm-c/Object.h @@ -19,9 +19,9 @@ #ifndef LLVM_C_OBJECT_H #define LLVM_C_OBJECT_H -#include "ExternC.h" -#include "Types.h" -#include "Config/llvm-config.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" +#include "llvm-c/Config/llvm-config.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Orc.h b/src/llvm-c/Orc.h index ecd110b4d..8609a8a6d 100644 --- a/src/llvm-c/Orc.h +++ b/src/llvm-c/Orc.h @@ -27,9 +27,9 @@ #ifndef LLVM_C_ORC_H #define LLVM_C_ORC_H -#include "Error.h" -#include "TargetMachine.h" -#include "Types.h" +#include "llvm-c/Error.h" +#include "llvm-c/TargetMachine.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN @@ -181,6 +181,15 @@ typedef struct { */ typedef LLVMOrcCDependenceMapPair *LLVMOrcCDependenceMapPairs; +/** + * A set of symbols that share dependencies. + */ +typedef struct { + LLVMOrcCSymbolsList Symbols; + LLVMOrcCDependenceMapPairs Dependencies; + size_t NumDependencies; +} LLVMOrcCSymbolDependenceGroup; + /** * Lookup kind. This can be used by definition generators when deciding whether * to produce a definition for a requested symbol. @@ -808,6 +817,19 @@ LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved( * that all symbols covered by this MaterializationResponsibility instance * have been emitted. * + * This function takes ownership of the symbols in the Dependencies struct. + * This allows the following pattern... + * + * LLVMOrcSymbolStringPoolEntryRef Names[] = {...}; + * LLVMOrcCDependenceMapPair Dependence = {JD, {Names, sizeof(Names)}} + * LLVMOrcMaterializationResponsibilityAddDependencies(JD, Name, &Dependence, + * 1); + * + * ... without requiring cleanup of the elements of the Names array afterwards. + * + * The client is still responsible for deleting the Dependencies.Names arrays, + * and the Dependencies array itself. + * * This method will return an error if any symbols being resolved have been * moved to the error state due to the failure of a dependency. If this * method returns an error then clients should log it and call @@ -817,7 +839,8 @@ LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved( * LLVMErrorSuccess. */ LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted( - LLVMOrcMaterializationResponsibilityRef MR); + LLVMOrcMaterializationResponsibilityRef MR, + LLVMOrcCSymbolDependenceGroup *SymbolDepGroups, size_t NumSymbolDepGroups); /** * Attempt to claim responsibility for new definitions. This method can be @@ -870,38 +893,6 @@ LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate( LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols, LLVMOrcMaterializationResponsibilityRef *Result); -/** - * Adds dependencies to a symbol that the MaterializationResponsibility is - * responsible for. - * - * This function takes ownership of Dependencies struct. The Names - * array have been retained for this function. This allows the following - * pattern... - * - * LLVMOrcSymbolStringPoolEntryRef Names[] = {...}; - * LLVMOrcCDependenceMapPair Dependence = {JD, {Names, sizeof(Names)}} - * LLVMOrcMaterializationResponsibilityAddDependencies(JD, Name, &Dependence, - * 1); - * - * ... without requiring cleanup of the elements of the Names array afterwards. - * - * The client is still responsible for deleting the Dependencies.Names array - * itself. - */ -void LLVMOrcMaterializationResponsibilityAddDependencies( - LLVMOrcMaterializationResponsibilityRef MR, - LLVMOrcSymbolStringPoolEntryRef Name, - LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs); - -/** - * Adds dependencies to all symbols that the MaterializationResponsibility is - * responsible for. See LLVMOrcMaterializationResponsibilityAddDependencies for - * notes about memory responsibility. - */ -void LLVMOrcMaterializationResponsibilityAddDependenciesForAll( - LLVMOrcMaterializationResponsibilityRef MR, - LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs); - /** * Create a "bare" JITDylib. * diff --git a/src/llvm-c/OrcEE.h b/src/llvm-c/OrcEE.h index aef24c7aa..d451187aa 100644 --- a/src/llvm-c/OrcEE.h +++ b/src/llvm-c/OrcEE.h @@ -24,11 +24,11 @@ #ifndef LLVM_C_ORCEE_H #define LLVM_C_ORCEE_H -#include "Error.h" -#include "ExecutionEngine.h" -#include "Orc.h" -#include "TargetMachine.h" -#include "Types.h" +#include "llvm-c/Error.h" +#include "llvm-c/ExecutionEngine.h" +#include "llvm-c/Orc.h" +#include "llvm-c/TargetMachine.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Remarks.h b/src/llvm-c/Remarks.h index 548a4041a..ffe647a65 100644 --- a/src/llvm-c/Remarks.h +++ b/src/llvm-c/Remarks.h @@ -15,8 +15,8 @@ #ifndef LLVM_C_REMARKS_H #define LLVM_C_REMARKS_H -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" #ifdef __cplusplus #include #else diff --git a/src/llvm-c/Support.h b/src/llvm-c/Support.h index 31a75354c..17657861b 100644 --- a/src/llvm-c/Support.h +++ b/src/llvm-c/Support.h @@ -14,9 +14,9 @@ #ifndef LLVM_C_SUPPORT_H #define LLVM_C_SUPPORT_H -#include "DataTypes.h" -#include "ExternC.h" -#include "Types.h" +#include "llvm-c/DataTypes.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Target.h b/src/llvm-c/Target.h index 4d03741c4..54367a41b 100644 --- a/src/llvm-c/Target.h +++ b/src/llvm-c/Target.h @@ -19,9 +19,9 @@ #ifndef LLVM_C_TARGET_H #define LLVM_C_TARGET_H -#include "ExternC.h" -#include "Types.h" -#include "Config/llvm-config.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Types.h" +#include "llvm-c/Config/llvm-config.h" LLVM_C_EXTERN_C_BEGIN @@ -40,34 +40,34 @@ typedef struct LLVMOpaqueTargetLibraryInfotData *LLVMTargetLibraryInfoRef; /* Declare all of the target-initialization functions that are available. */ #define LLVM_TARGET(TargetName) \ void LLVMInitialize##TargetName##TargetInfo(void); -#include "Config/Targets.def" +#include "llvm-c/Config/Targets.def" #undef LLVM_TARGET /* Explicit undef to make SWIG happier */ #define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##Target(void); -#include "Config/Targets.def" +#include "llvm-c/Config/Targets.def" #undef LLVM_TARGET /* Explicit undef to make SWIG happier */ #define LLVM_TARGET(TargetName) \ void LLVMInitialize##TargetName##TargetMC(void); -#include "Config/Targets.def" +#include "llvm-c/Config/Targets.def" #undef LLVM_TARGET /* Explicit undef to make SWIG happier */ /* Declare all of the available assembly printer initialization functions. */ #define LLVM_ASM_PRINTER(TargetName) \ void LLVMInitialize##TargetName##AsmPrinter(void); -#include "Config/AsmPrinters.def" +#include "llvm-c/Config/AsmPrinters.def" #undef LLVM_ASM_PRINTER /* Explicit undef to make SWIG happier */ /* Declare all of the available assembly parser initialization functions. */ #define LLVM_ASM_PARSER(TargetName) \ void LLVMInitialize##TargetName##AsmParser(void); -#include "Config/AsmParsers.def" +#include "llvm-c/Config/AsmParsers.def" #undef LLVM_ASM_PARSER /* Explicit undef to make SWIG happier */ /* Declare all of the available disassembler initialization functions. */ #define LLVM_DISASSEMBLER(TargetName) \ void LLVMInitialize##TargetName##Disassembler(void); -#include "Config/Disassemblers.def" +#include "llvm-c/Config/Disassemblers.def" #undef LLVM_DISASSEMBLER /* Explicit undef to make SWIG happier */ /** LLVMInitializeAllTargetInfos - The main program should call this function if @@ -75,7 +75,7 @@ typedef struct LLVMOpaqueTargetLibraryInfotData *LLVMTargetLibraryInfoRef; support. */ static inline void LLVMInitializeAllTargetInfos(void) { #define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetInfo(); -#include "Config/Targets.def" +#include "llvm-c/Config/Targets.def" #undef LLVM_TARGET /* Explicit undef to make SWIG happier */ } @@ -84,7 +84,7 @@ static inline void LLVMInitializeAllTargetInfos(void) { support. */ static inline void LLVMInitializeAllTargets(void) { #define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##Target(); -#include "Config/Targets.def" +#include "llvm-c/Config/Targets.def" #undef LLVM_TARGET /* Explicit undef to make SWIG happier */ } @@ -93,7 +93,7 @@ static inline void LLVMInitializeAllTargets(void) { support. */ static inline void LLVMInitializeAllTargetMCs(void) { #define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetMC(); -#include "Config/Targets.def" +#include "llvm-c/Config/Targets.def" #undef LLVM_TARGET /* Explicit undef to make SWIG happier */ } @@ -102,7 +102,7 @@ static inline void LLVMInitializeAllTargetMCs(void) { available via the TargetRegistry. */ static inline void LLVMInitializeAllAsmPrinters(void) { #define LLVM_ASM_PRINTER(TargetName) LLVMInitialize##TargetName##AsmPrinter(); -#include "Config/AsmPrinters.def" +#include "llvm-c/Config/AsmPrinters.def" #undef LLVM_ASM_PRINTER /* Explicit undef to make SWIG happier */ } @@ -111,7 +111,7 @@ static inline void LLVMInitializeAllAsmPrinters(void) { available via the TargetRegistry. */ static inline void LLVMInitializeAllAsmParsers(void) { #define LLVM_ASM_PARSER(TargetName) LLVMInitialize##TargetName##AsmParser(); -#include "Config/AsmParsers.def" +#include "llvm-c/Config/AsmParsers.def" #undef LLVM_ASM_PARSER /* Explicit undef to make SWIG happier */ } @@ -121,7 +121,7 @@ static inline void LLVMInitializeAllAsmParsers(void) { static inline void LLVMInitializeAllDisassemblers(void) { #define LLVM_DISASSEMBLER(TargetName) \ LLVMInitialize##TargetName##Disassembler(); -#include "Config/Disassemblers.def" +#include "llvm-c/Config/Disassemblers.def" #undef LLVM_DISASSEMBLER /* Explicit undef to make SWIG happier */ } @@ -244,7 +244,7 @@ LLVMTypeRef LLVMIntPtrTypeInContext(LLVMContextRef C, LLVMTargetDataRef TD); LLVMTypeRef LLVMIntPtrTypeForASInContext(LLVMContextRef C, LLVMTargetDataRef TD, unsigned AS); -/** Computes the size of a type in bytes for a target. +/** Computes the size of a type in bits for a target. See the method llvm::DataLayout::getTypeSizeInBits. */ unsigned long long LLVMSizeOfTypeInBits(LLVMTargetDataRef TD, LLVMTypeRef Ty); diff --git a/src/llvm-c/TargetMachine.h b/src/llvm-c/TargetMachine.h index aa628e216..cbe891380 100644 --- a/src/llvm-c/TargetMachine.h +++ b/src/llvm-c/TargetMachine.h @@ -19,9 +19,9 @@ #ifndef LLVM_C_TARGETMACHINE_H #define LLVM_C_TARGETMACHINE_H -#include "ExternC.h" -#include "Target.h" -#include "Types.h" +#include "llvm-c/ExternC.h" +#include "llvm-c/Target.h" +#include "llvm-c/Types.h" LLVM_C_EXTERN_C_BEGIN diff --git a/src/llvm-c/Transforms/PassBuilder.h b/src/llvm-c/Transforms/PassBuilder.h index 8ad2a9982..d297b57ca 100644 --- a/src/llvm-c/Transforms/PassBuilder.h +++ b/src/llvm-c/Transforms/PassBuilder.h @@ -14,9 +14,9 @@ #ifndef LLVM_C_TRANSFORMS_PASSBUILDER_H #define LLVM_C_TRANSFORMS_PASSBUILDER_H -#include "../Error.h" -#include "../TargetMachine.h" -#include "../Types.h" +#include "llvm-c/Error.h" +#include "llvm-c/TargetMachine.h" +#include "llvm-c/Types.h" /** * @defgroup LLVMCCoreNewPM New Pass Manager @@ -50,6 +50,16 @@ LLVMErrorRef LLVMRunPasses(LLVMModuleRef M, const char *Passes, LLVMTargetMachineRef TM, LLVMPassBuilderOptionsRef Options); +/** + * Construct and run a set of passes over a function. + * + * This function behaves the same as LLVMRunPasses, but operates on a single + * function instead of an entire module. + */ +LLVMErrorRef LLVMRunPassesOnFunction(LLVMValueRef F, const char *Passes, + LLVMTargetMachineRef TM, + LLVMPassBuilderOptionsRef Options); + /** * Create a new set of options for a PassBuilder * @@ -72,6 +82,14 @@ void LLVMPassBuilderOptionsSetVerifyEach(LLVMPassBuilderOptionsRef Options, void LLVMPassBuilderOptionsSetDebugLogging(LLVMPassBuilderOptionsRef Options, LLVMBool DebugLogging); +/** + * Specify a custom alias analysis pipeline for the PassBuilder to be used + * instead of the default one. The string argument is not copied; the caller + * is responsible for ensuring it outlives the PassBuilderOptions instance. + */ +void LLVMPassBuilderOptionsSetAAPipeline(LLVMPassBuilderOptionsRef Options, + const char *AAPipeline); + void LLVMPassBuilderOptionsSetLoopInterleaving( LLVMPassBuilderOptionsRef Options, LLVMBool LoopInterleaving); diff --git a/src/llvm-c/Types.h b/src/llvm-c/Types.h index 77aa7c9b4..4681500ef 100644 --- a/src/llvm-c/Types.h +++ b/src/llvm-c/Types.h @@ -14,8 +14,8 @@ #ifndef LLVM_C_TYPES_H #define LLVM_C_TYPES_H -#include "DataTypes.h" -#include "ExternC.h" +#include "llvm-c/DataTypes.h" +#include "llvm-c/ExternC.h" LLVM_C_EXTERN_C_BEGIN @@ -169,6 +169,11 @@ typedef struct LLVMOpaqueJITEventListener *LLVMJITEventListenerRef; */ typedef struct LLVMOpaqueBinary *LLVMBinaryRef; +/** + * @see llvm::DbgRecord + */ +typedef struct LLVMOpaqueDbgRecord *LLVMDbgRecordRef; + /** * @} */ diff --git a/src/llvm-c/lto.h b/src/llvm-c/lto.h index 89f76c695..5ceb02224 100644 --- a/src/llvm-c/lto.h +++ b/src/llvm-c/lto.h @@ -16,7 +16,7 @@ #ifndef LLVM_C_LTO_H #define LLVM_C_LTO_H -#include "ExternC.h" +#include "llvm-c/ExternC.h" #ifdef __cplusplus #include diff --git a/src/llvm_abi.cpp b/src/llvm_abi.cpp index 0b2bb7956..6d9f6d958 100644 --- a/src/llvm_abi.cpp +++ b/src/llvm_abi.cpp @@ -256,8 +256,10 @@ gb_internal i64 lb_sizeof(LLVMTypeRef type) { } break; +#if LLVM_VERSION_MAJOR < 20 case LLVMX86_MMXTypeKind: return 8; +#endif case LLVMVectorTypeKind: { LLVMTypeRef elem = OdinLLVMGetVectorElementType(type); @@ -310,8 +312,10 @@ gb_internal i64 lb_alignof(LLVMTypeRef type) { case LLVMArrayTypeKind: return lb_alignof(OdinLLVMGetArrayElementType(type)); +#if LLVM_VERSION_MAJOR < 20 case LLVMX86_MMXTypeKind: return 8; +#endif case LLVMVectorTypeKind: { // TODO(bill): This appears to be correct but LLVM isn't necessarily "great" with regards to documentation diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 75fbbe941..c3afac115 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -1591,797 +1591,7 @@ gb_internal WORKER_TASK_PROC(lb_llvm_module_pass_worker_proc) { LLVMPassBuilderOptionsRef pb_options = LLVMCreatePassBuilderOptions(); defer (LLVMDisposePassBuilderOptions(pb_options)); - switch (build_context.optimization_level) { - case -1: - array_add(&passes, "function(annotation-remarks)"); - break; - case 0: - array_add(&passes, "always-inline"); - array_add(&passes, "function(annotation-remarks)"); - break; - case 1: -// default -// Passes removed: coro, openmp, sroa -#if LLVM_VERSION_MAJOR == 17 - array_add(&passes, u8R"( -annotation2metadata, -forceattrs, -inferattrs, -function( - lower-expect, - simplifycfg, - early-cse<> -), -ipsccp, -called-value-propagation, -globalopt, -function( - mem2reg, - instcombine, - simplifycfg -), -require, -function( - invalidate -), -require, -cgscc( - devirt<4>( - inline, - inline, - function-attrs, - function( - early-cse, - speculative-execution, - jump-threading, - correlated-propagation, - simplifycfg, - instcombine, - aggressive-instcombine, - constraint-elimination, - tailcallelim, - simplifycfg, - reassociate, - loop-mssa( - loop-instsimplify, - loop-simplifycfg, - licm, - loop-rotate, - licm, - simple-loop-unswitch - ), - simplifycfg, - instcombine, - loop( - loop-idiom, - indvars, - loop-deletion, - loop-unroll-full - ), - vector-combine, - mldst-motion, - gvn<>, - sccp, - bdce, - instcombine, - jump-threading, - correlated-propagation, - adce, - memcpyopt, - dse, - move-auto-init, - loop-mssa( - licm - ), - simplifycfg, - instcombine - ), - function-attrs, - function( - require - ) - ) -), -deadargelim, -globalopt, -globaldce, -elim-avail-extern, -rpo-function-attrs, -recompute-globalsaa, -function( - float2int, - lower-constant-intrinsics, - loop( - loop-rotate, - loop-deletion - ), - loop-distribute, - inject-tli-mappings, - loop-vectorize, - loop-load-elim, - instcombine, - simplifycfg, - slp-vectorizer, - vector-combine, - instcombine, - loop-unroll, - transform-warning, - instcombine, - loop-mssa( - licm - ), - alignment-from-assumptions, - loop-sink, - instsimplify, - div-rem-pairs, - tailcallelim, - simplifycfg -), -globaldce, -constmerge, -cg-profile, -rel-lookup-table-converter, -function( - annotation-remarks -), -verify -)"); -#else - array_add(&passes, u8R"( -annotation2metadata, -forceattrs, -inferattrs, -function( - lower-expect, - simplifycfg, - sroa, - early-cse<> -), -ipsccp, -called-value-propagation, -globalopt, -function( - mem2reg, - instcombine, - simplifycfg -), -always-inline, -require, -function( - invalidate -), -require, -cgscc( - devirt<4>( - inline, - function-attrs, - function( - sroa, - early-cse, - speculative-execution, - jump-threading, - correlated-propagation, - simplifycfg, - instcombine, - aggressive-instcombine, - tailcallelim, - simplifycfg, - reassociate, - constraint-elimination, - loop-mssa( - loop-instsimplify, - loop-simplifycfg, - licm, - loop-rotate, - licm, - simple-loop-unswitch - ), - simplifycfg, - instcombine, - loop( - loop-idiom, - indvars, - loop-deletion, - loop-unroll-full - ), - sroa, - vector-combine, - mldst-motion, - gvn<>, - sccp, - bdce, - instcombine, - jump-threading, - correlated-propagation, - adce, - memcpyopt, - dse, - move-auto-init, - loop-mssa( - licm - ), - simplifycfg, - instcombine - ), - function-attrs, - function( - require - ) - ) -), -deadargelim, -globalopt, -globaldce, -elim-avail-extern, -rpo-function-attrs, -recompute-globalsaa, -function( - float2int, - lower-constant-intrinsics, - loop( - loop-rotate, - loop-deletion - ), - loop-distribute, - inject-tli-mappings, - loop-vectorize, - infer-alignment, - loop-load-elim, - instcombine, - simplifycfg, - slp-vectorizer, - vector-combine, - instcombine, - loop-unroll, - transform-warning, - sroa, - infer-alignment, - instcombine, - loop-mssa( - licm - ), - alignment-from-assumptions, - loop-sink, - instsimplify, - div-rem-pairs, - tailcallelim, - simplifycfg -), -globaldce, -constmerge, -cg-profile, -rel-lookup-table-converter, -function( - annotation-remarks -), -verify -)"); -#endif - break; -// default -// Passes removed: coro, openmp, sroa - case 2: -#if LLVM_VERSION_MAJOR == 17 - array_add(&passes, u8R"( -annotation2metadata, -forceattrs, -inferattrs, -function( - lower-expect, - simplifycfg, - early-cse<> -), -ipsccp, -called-value-propagation, -globalopt, -function( - mem2reg, - instcombine, - simplifycfg -), -require, -function( - invalidate -), -require, -cgscc( - devirt<4>( - inline, - inline, - function-attrs, - function( - early-cse, - speculative-execution, - jump-threading, - correlated-propagation, - simplifycfg, - instcombine, - aggressive-instcombine, - constraint-elimination, - libcalls-shrinkwrap, - tailcallelim, - simplifycfg, - reassociate, - loop-mssa( - loop-instsimplify, - loop-simplifycfg, - licm, - loop-rotate, - licm, - simple-loop-unswitch - ), - simplifycfg, - instcombine, - loop( - loop-idiom, - indvars, - loop-deletion, - loop-unroll-full - ), - vector-combine, - mldst-motion, - gvn<>, - sccp, - bdce, - instcombine, - jump-threading, - correlated-propagation, - adce, - memcpyopt, - dse, - move-auto-init, - loop-mssa( - licm - ), - simplifycfg, - instcombine - ), - function-attrs, - function( - require - ) - ) -), -deadargelim, -globalopt, -globaldce, -elim-avail-extern, -rpo-function-attrs, -recompute-globalsaa, -function( - float2int, - lower-constant-intrinsics, - loop( - loop-rotate, - loop-deletion - ), - loop-distribute, - inject-tli-mappings, - loop-vectorize, - loop-load-elim, - instcombine, - simplifycfg, - slp-vectorizer, - vector-combine, - instcombine, - loop-unroll, - transform-warning, - instcombine, - loop-mssa( - licm - ), - alignment-from-assumptions, - loop-sink, - instsimplify, - div-rem-pairs, - tailcallelim, - simplifycfg -), -globaldce, -constmerge, -cg-profile, -rel-lookup-table-converter, -function( - annotation-remarks -), -verify -)"); -#else - array_add(&passes, u8R"( -annotation2metadata, -forceattrs, -inferattrs, -function( - lower-expect, - simplifycfg, - sroa, - early-cse<> -), -ipsccp, -called-value-propagation, -globalopt, -function( - mem2reg, - instcombine, - simplifycfg -), -always-inline, -require, -function( - invalidate -), -require, -cgscc( - devirt<4>( - inline, - function-attrs, - function( - sroa, - early-cse, - speculative-execution, - jump-threading, - correlated-propagation, - simplifycfg, - instcombine, - aggressive-instcombine, - libcalls-shrinkwrap, - tailcallelim, - simplifycfg, - reassociate, - constraint-elimination, - loop-mssa( - loop-instsimplify, - loop-simplifycfg, - licm, - loop-rotate, - licm, - simple-loop-unswitch - ), - simplifycfg, - instcombine, - loop( - loop-idiom, - indvars, - loop-deletion, - loop-unroll-full - ), - sroa, - vector-combine, - mldst-motion, - gvn<>, - sccp, - bdce, - instcombine, - jump-threading, - correlated-propagation, - adce, - memcpyopt, - dse, - move-auto-init, - loop-mssa( - licm - ), - simplifycfg, - instcombine - ), - function-attrs, - function( - require - ) - ) -), -deadargelim, -globalopt, -globaldce, -elim-avail-extern, -rpo-function-attrs, -recompute-globalsaa, -function( - float2int, - lower-constant-intrinsics, - loop( - loop-rotate, - loop-deletion - ), - loop-distribute, - inject-tli-mappings, - loop-vectorize, - infer-alignment, - loop-load-elim, - instcombine, - simplifycfg, - slp-vectorizer, - vector-combine, - instcombine, - loop-unroll, - transform-warning, - sroa, - infer-alignment, - instcombine, - loop-mssa( - licm - ), - alignment-from-assumptions, - loop-sink, - instsimplify, - div-rem-pairs, - tailcallelim, - simplifycfg -), -globaldce, -constmerge, -cg-profile, -rel-lookup-table-converter, -function( - annotation-remarks -), -verify -)"); -#endif - break; - - case 3: -// default -// Passes removed: coro, openmp, sroa -#if LLVM_VERSION_MAJOR == 17 - array_add(&passes, u8R"( -annotation2metadata, -forceattrs, -inferattrs, -function( - lower-expect, - simplifycfg, - early-cse<>, - callsite-splitting -), -ipsccp, -called-value-propagation, -globalopt, -function( - mem2reg, - instcombine, - simplifycfg -), -require, -function( - invalidate -), -require, -cgscc( - devirt<4>( - inline, - inline, - function-attrs, - argpromotion, - function( - early-cse, - speculative-execution, - jump-threading, - correlated-propagation, - simplifycfg, - instcombine, - aggressive-instcombine, - constraint-elimination, - libcalls-shrinkwrap, - tailcallelim, - simplifycfg, - reassociate, - loop-mssa( - loop-instsimplify, - loop-simplifycfg, - licm, - loop-rotate, - licm, - simple-loop-unswitch - ), - simplifycfg, - instcombine, - loop( - loop-idiom, - indvars, - loop-deletion, - loop-unroll-full - ), - vector-combine, - mldst-motion, - gvn<>, - sccp, - bdce, - instcombine, - jump-threading, - correlated-propagation, - adce, - memcpyopt, - dse, - move-auto-init, - loop-mssa( - licm - ), - simplifycfg, - instcombine - ), - function-attrs, - function( - require - ) - ) -), -deadargelim, -globalopt, -globaldce, -elim-avail-extern, -rpo-function-attrs, -recompute-globalsaa, -function( - float2int, - lower-constant-intrinsics, - chr, - loop( - loop-rotate, - loop-deletion - ), - loop-distribute, - inject-tli-mappings, - loop-vectorize, - loop-load-elim, - instcombine, - simplifycfg, - slp-vectorizer, - vector-combine, - instcombine, - loop-unroll, - transform-warning, - instcombine, - loop-mssa( - licm - ), - alignment-from-assumptions, - loop-sink, - instsimplify, - div-rem-pairs, - tailcallelim, - simplifycfg -), -globaldce, -constmerge, -cg-profile, -rel-lookup-table-converter, -function( - annotation-remarks -), -verify -)"); -#else - array_add(&passes, u8R"( -annotation2metadata, -forceattrs, -inferattrs, -function( - lower-expect, - simplifycfg, - sroa, - early-cse<>, - callsite-splitting -), -ipsccp, -called-value-propagation, -globalopt, -function( - mem2reg, - instcombine, - simplifycfg -), -always-inline, -require, -function(invalidate), -require, -cgscc( - devirt<4>( - inline, - function-attrs, - argpromotion, - function( - sroa, - early-cse, - speculative-execution, - jump-threading, - correlated-propagation, - simplifycfg, - instcombine, - aggressive-instcombine, - libcalls-shrinkwrap, - tailcallelim, - simplifycfg, - reassociate, - constraint-elimination, - loop-mssa( - loop-instsimplify, - loop-simplifycfg, - licm, - loop-rotate, - licm, - simple-loop-unswitch - ), - simplifycfg, - instcombine, - loop( - loop-idiom, - indvars, - loop-deletion, - loop-unroll-full - ), - sroa, - vector-combine, - mldst-motion, - gvn<>, - sccp, - bdce, - instcombine, - jump-threading, - correlated-propagation, - adce, - memcpyopt, - dse, - move-auto-init, - loop-mssa(licm), - simplifycfg, - instcombine - ), - function-attrs, - function( - require - ) - ) -), -deadargelim, -globalopt, -globaldce, -elim-avail-extern, -rpo-function-attrs, -recompute-globalsaa, -function( - float2int, - lower-constant-intrinsics, - chr, - loop( - loop-rotate, - loop-deletion - ), - loop-distribute, - inject-tli-mappings, - loop-vectorize, - infer-alignment, - loop-load-elim, - instcombine, - simplifycfg, - slp-vectorizer, - vector-combine, - instcombine, - loop-unroll, - transform-warning, - sroa, - infer-alignment, - instcombine, - loop-mssa(licm), - alignment-from-assumptions, - loop-sink, - instsimplify, - div-rem-pairs, - tailcallelim, - simplifycfg -), -globaldce, -constmerge, -cg-profile, -rel-lookup-table-converter, -function( - annotation-remarks -), -verify -)"); -#endif - break; - } + #include "llvm_backend_passes.cpp" // asan - Linux, Darwin, Windows // msan - linux @@ -2591,7 +1801,7 @@ gb_internal String lb_filepath_obj_for_module(lbModule *m) { path = gb_string_appendc(path, "/"); path = gb_string_append_length(path, name.text, name.len); - { + if (USE_SEPARATE_MODULES) { GB_ASSERT(m->module_name != nullptr); String s = make_string_c(m->module_name); String prefix = str_lit("odin_package"); @@ -2958,13 +2168,16 @@ gb_internal bool lb_generate_code(lbGenerator *gen) { LLVMInitializeWebAssemblyAsmParser(); LLVMInitializeWebAssemblyDisassembler(); break; + case TargetArch_riscv64: + LLVMInitializeRISCVTargetInfo(); + LLVMInitializeRISCVTarget(); + LLVMInitializeRISCVTargetMC(); + LLVMInitializeRISCVAsmPrinter(); + LLVMInitializeRISCVAsmParser(); + LLVMInitializeRISCVDisassembler(); + break; default: - LLVMInitializeAllTargetInfos(); - LLVMInitializeAllTargets(); - LLVMInitializeAllTargetMCs(); - LLVMInitializeAllAsmPrinters(); - LLVMInitializeAllAsmParsers(); - LLVMInitializeAllDisassemblers(); + GB_PANIC("Unimplemented LLVM target initialization"); break; } diff --git a/src/llvm_backend_debug.cpp b/src/llvm_backend_debug.cpp index 067004bc1..926daaae4 100644 --- a/src/llvm_backend_debug.cpp +++ b/src/llvm_backend_debug.cpp @@ -1085,7 +1085,12 @@ gb_internal void lb_add_debug_local_variable(lbProcedure *p, LLVMValueRef ptr, T LLVMMetadataRef llvm_debug_loc = lb_debug_location_from_token_pos(p, token.pos); LLVMMetadataRef llvm_expr = LLVMDIBuilderCreateExpression(m->debug_builder, nullptr, 0); lb_set_llvm_metadata(m, ptr, llvm_expr); + +#if LLVM_VERSION_MAJOR <= 18 LLVMDIBuilderInsertDeclareAtEnd(m->debug_builder, storage, var_info, llvm_expr, llvm_debug_loc, block); +#else + LLVMDIBuilderInsertDbgValueRecordAtEnd(m->debug_builder, storage, var_info, llvm_expr, llvm_debug_loc, block); +#endif } gb_internal void lb_add_debug_param_variable(lbProcedure *p, LLVMValueRef ptr, Type *type, Token const &token, unsigned arg_number, lbBlock *block) { diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp index 56c7b45ec..ea3db33f4 100644 --- a/src/llvm_backend_expr.cpp +++ b/src/llvm_backend_expr.cpp @@ -2145,6 +2145,12 @@ gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) { } } for (Type *vt : dst->Union.variants) { + if (src_type == t_llvm_bool && is_type_boolean(vt)) { + value = lb_emit_conv(p, value, vt); + lbAddr parent = lb_add_local_generated(p, t, true); + lb_emit_store_union_variant(p, parent.addr, value, vt); + return lb_addr_load(p, parent); + } if (are_types_identical(src_type, vt)) { lbAddr parent = lb_add_local_generated(p, t, true); lb_emit_store_union_variant(p, parent.addr, value, vt); diff --git a/src/llvm_backend_passes.cpp b/src/llvm_backend_passes.cpp new file mode 100644 index 000000000..bea95ce8e --- /dev/null +++ b/src/llvm_backend_passes.cpp @@ -0,0 +1,1195 @@ + switch (build_context.optimization_level) { + case -1: + array_add(&passes, "function(annotation-remarks)"); + break; + case 0: + array_add(&passes, "always-inline"); + array_add(&passes, "function(annotation-remarks)"); + break; + case 1: +// default +// Passes removed: coro, openmp, sroa +#if LLVM_VERSION_MAJOR == 17 + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + lower-expect, + simplifycfg, + early-cse<> +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + inline, + function-attrs, + function( + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + constraint-elimination, + tailcallelim, + simplifycfg, + reassociate, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + loop-deletion, + loop-unroll-full + ), + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); +#elif LLVM_VERSION_MAJOR < 20 + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + lower-expect, + simplifycfg, + sroa, + early-cse<> +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +always-inline, +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + function-attrs, + function( + sroa, + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + tailcallelim, + simplifycfg, + reassociate, + constraint-elimination, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + loop-deletion, + loop-unroll-full + ), + sroa, + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + infer-alignment, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + sroa, + infer-alignment, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); +#else + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + ee-instrument<>, + lower-expect, + simplifycfg, + sroa, + early-cse<> +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +always-inline, +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + function-attrs, + function( + sroa, + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + tailcallelim, + simplifycfg, + reassociate, + constraint-elimination, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + extra-simple-loop-unswitch-passes, + loop-deletion,loop-unroll-full + ), + sroa, + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + infer-alignment, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + sroa, + infer-alignment, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); + +#endif + break; +// default +// Passes removed: coro, openmp, sroa + case 2: +#if LLVM_VERSION_MAJOR == 17 + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + lower-expect, + simplifycfg, + early-cse<> +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + inline, + function-attrs, + function( + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + constraint-elimination, + libcalls-shrinkwrap, + tailcallelim, + simplifycfg, + reassociate, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + loop-deletion, + loop-unroll-full + ), + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); +#elif LLVM_VERSION_MAJOR < 20 + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + lower-expect, + simplifycfg, + sroa, + early-cse<> +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +always-inline, +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + function-attrs, + function( + sroa, + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + libcalls-shrinkwrap, + tailcallelim, + simplifycfg, + reassociate, + constraint-elimination, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + loop-deletion, + loop-unroll-full + ), + sroa, + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + infer-alignment, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + sroa, + infer-alignment, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); +#else + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + ee-instrument<>, + lower-expect, + simplifycfg, + sroa, + early-cse<> +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +always-inline, +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + function-attrs, + function( + sroa, + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + libcalls-shrinkwrap, + tailcallelim, + simplifycfg, + reassociate, + constraint-elimination, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + extra-simple-loop-unswitch-passes, + loop-deletion, + loop-unroll-full + ), + sroa, + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + infer-alignment, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + sroa, + infer-alignment, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); +#endif + break; + + case 3: +// default +// Passes removed: coro, openmp, sroa +#if LLVM_VERSION_MAJOR == 17 + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + lower-expect, + simplifycfg, + early-cse<>, + callsite-splitting +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + inline, + function-attrs, + argpromotion, + function( + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + constraint-elimination, + libcalls-shrinkwrap, + tailcallelim, + simplifycfg, + reassociate, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + loop-deletion, + loop-unroll-full + ), + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + chr, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); + +#elif LLVM_VERSION_MAJOR < 20 + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + lower-expect, + simplifycfg, + sroa, + early-cse<>, + callsite-splitting +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +always-inline, +require, +function(invalidate), +require, +cgscc( + devirt<4>( + inline, + function-attrs, + argpromotion, + function( + sroa, + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + libcalls-shrinkwrap, + tailcallelim, + simplifycfg, + reassociate, + constraint-elimination, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + loop-deletion, + loop-unroll-full + ), + sroa, + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa(licm), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + chr, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + infer-alignment, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + sroa, + infer-alignment, + instcombine, + loop-mssa(licm), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify +)"); +#else + array_add(&passes, u8R"( +annotation2metadata, +forceattrs, +inferattrs, +function( + ee-instrument<>, + lower-expect, + simplifycfg, + sroa, + early-cse<>, + callsite-splitting +), +ipsccp, +called-value-propagation, +globalopt, +function( + mem2reg, + instcombine, + simplifycfg +), +always-inline, +require, +function( + invalidate +), +require, +cgscc( + devirt<4>( + inline, + function-attrs, + argpromotion, + function( + sroa, + early-cse, + speculative-execution, + jump-threading, + correlated-propagation, + simplifycfg, + instcombine, + aggressive-instcombine, + libcalls-shrinkwrap, + tailcallelim, + simplifycfg, + reassociate, + constraint-elimination, + loop-mssa( + loop-instsimplify, + loop-simplifycfg, + licm, + loop-rotate, + licm, + simple-loop-unswitch + ), + simplifycfg, + instcombine, + loop( + loop-idiom, + indvars, + extra-simple-loop-unswitch-passes, + loop-deletion, + loop-unroll-full + ), + sroa, + vector-combine, + mldst-motion, + gvn<>, + sccp, + bdce, + instcombine, + jump-threading, + correlated-propagation, + adce, + memcpyopt, + dse, + move-auto-init, + loop-mssa( + licm + ), + simplifycfg, + instcombine + ), + function-attrs, + function( + require + ) + ) +), +deadargelim, +globalopt, +globaldce, +elim-avail-extern, +rpo-function-attrs, +recompute-globalsaa, +function( + float2int, + lower-constant-intrinsics, + chr, + loop( + loop-rotate, + loop-deletion + ), + loop-distribute, + inject-tli-mappings, + loop-vectorize, + infer-alignment, + loop-load-elim, + instcombine, + simplifycfg, + slp-vectorizer, + vector-combine, + instcombine, + loop-unroll, + transform-warning, + sroa, + infer-alignment, + instcombine, + loop-mssa( + licm + ), + alignment-from-assumptions, + loop-sink, + instsimplify, + div-rem-pairs, + tailcallelim, + simplifycfg +), +globaldce, +constmerge, +cg-profile, +rel-lookup-table-converter, +function( + annotation-remarks +), +verify + +)"); + +#endif + break; + } \ No newline at end of file diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index a835ae2c8..ad14e4fcd 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -3621,6 +3621,7 @@ gb_internal lbValue lb_build_call_expr_internal(lbProcedure *p, Ast *expr) { GB_ASSERT(ce->args.count == 1); lbValue x = lb_build_expr(p, ce->args[0]); lbValue y = lb_emit_conv(p, x, tv.type); + y.type = tv.type; return y; } diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp index 4fcb136b0..1f783b1be 100644 --- a/src/llvm_backend_stmt.cpp +++ b/src/llvm_backend_stmt.cpp @@ -1938,7 +1938,11 @@ gb_internal void lb_build_type_switch_stmt(lbProcedure *p, AstTypeSwitchStmt *ss lb_add_entity(p->module, case_entity, ptr); lb_add_debug_local_variable(p, ptr.value, case_entity->type, case_entity->token); } else { - lb_store_type_case_implicit(p, clause, parent_value, false); + if (by_reference) { + lb_store_type_case_implicit(p, clause, parent_ptr, false); + } else { + lb_store_type_case_implicit(p, clause, parent_value, false); + } } lb_type_case_body(p, ss->label, clause, body, done); diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp index c876169f3..c21e88792 100644 --- a/src/llvm_backend_utility.cpp +++ b/src/llvm_backend_utility.cpp @@ -2112,11 +2112,10 @@ gb_internal lbAddr lb_handle_objc_find_or_register_selector(lbProcedure *p, Stri } if (!entity) { - gbString global_name = gb_string_make(temporary_allocator(), "__$objc_SEL$"); + gbString global_name = gb_string_make(temporary_allocator(), "__$objc_SEL::"); global_name = gb_string_append_length(global_name, name.text, name.len); - lbAddr default_addr = lb_add_global_generated_with_name( - default_module, t_objc_SEL, {}, + lbAddr default_addr = lb_add_global_generated_with_name(default_module, t_objc_SEL, {}, make_string(cast(u8 const *)global_name, gb_string_length(global_name)), &entity); string_map_set(&default_module->objc_selectors, name, lbObjcRef{entity, default_addr}); @@ -2175,7 +2174,7 @@ gb_internal lbAddr lb_handle_objc_find_or_register_class(lbProcedure *p, String } if (!entity) { - gbString global_name = gb_string_make(temporary_allocator(), "__$objc_Class$"); + gbString global_name = gb_string_make(temporary_allocator(), "__$objc_Class::"); global_name = gb_string_append_length(global_name, name.text, name.len); lbAddr default_addr = lb_add_global_generated_with_name(default_module, t_objc_Class, {}, diff --git a/src/threading.cpp b/src/threading.cpp index af8fd803c..a0d1c4049 100644 --- a/src/threading.cpp +++ b/src/threading.cpp @@ -756,7 +756,7 @@ gb_internal void futex_signal(Futex *f) { perror("Futex wake"); GB_PANIC("futex wake fail"); - } else if (ret == 1) { + } else { return; } } @@ -773,7 +773,7 @@ gb_internal void futex_broadcast(Futex *f) { perror("Futex wake"); GB_PANIC("futex wake fail"); - } else if (ret == 1) { + } else { return; } } @@ -783,7 +783,7 @@ gb_internal void futex_wait(Futex *f, Footex val) { for (;;) { int ret = futex((volatile uint32_t *)f, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, NULL, NULL); if (ret == -1) { - if (*f != val) { + if (errno == EAGAIN) { return; } diff --git a/vendor/libc/ctype.odin b/vendor/libc/ctype.odin new file mode 100644 index 000000000..8813055d7 --- /dev/null +++ b/vendor/libc/ctype.odin @@ -0,0 +1,33 @@ +package odin_libc + +@(require, linkage="strong", link_name="isdigit") +isdigit :: proc "c" (c: i32) -> b32 { + switch c { + case '0'..='9': return true + case: return false + } +} + +@(require, linkage="strong", link_name="isblank") +isblank :: proc "c" (c: i32) -> b32 { + switch c { + case '\t', ' ': return true + case: return false + } +} + +@(require, linkage="strong", link_name="isspace") +isspace :: proc "c" (c: i32) -> b32 { + switch c { + case '\t', ' ', '\n', '\v', '\f', '\r': return true + case: return false + } +} + +@(require, linkage="strong", link_name="toupper") +toupper :: proc "c" (c: i32) -> i32 { + if c >= 'a' && c <= 'z' { + return c - ('a' - 'A') + } + return c +} diff --git a/vendor/libc/include/alloca.h b/vendor/libc/include/alloca.h new file mode 100644 index 000000000..8b4d19018 --- /dev/null +++ b/vendor/libc/include/alloca.h @@ -0,0 +1,21 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + +#include + +void *alloca(size_t); /* built-in for gcc */ + +#if defined(__GNUC__) && __GNUC__ >= 3 +/* built-in for gcc 3 */ +#undef alloca +#undef __alloca +#define alloca(size) __alloca(size) +#define __alloca(size) __builtin_alloca(size) +#endif + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/include/assert.h b/vendor/libc/include/assert.h index a6fb6c696..4e8cd85a4 100644 --- a/vendor/libc/include/assert.h +++ b/vendor/libc/include/assert.h @@ -1,3 +1,9 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + #ifdef NDEBUG #define assert(e) ((void)0) #else @@ -14,3 +20,9 @@ void __odin_libc_assert_fail(const char *, const char *, int, const char *); (__builtin_expect(!(e), 0) ? __odin_libc_assert_fail(__func__, __ASSERT_FILE_NAME, __LINE__, #e) : (void)0) #endif /* NDEBUG */ + +#define static_assert _Static_assert + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/include/ctype.h b/vendor/libc/include/ctype.h new file mode 100644 index 000000000..a579b5674 --- /dev/null +++ b/vendor/libc/include/ctype.h @@ -0,0 +1,15 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + +int isdigit(int c); +int isblank(int c); +int isspace(int c); + +int toupper(int c); + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/include/inttypes.h b/vendor/libc/include/inttypes.h new file mode 100644 index 000000000..e69de29bb diff --git a/vendor/libc/include/math.h b/vendor/libc/include/math.h index 9d486da11..9903ac3f9 100644 --- a/vendor/libc/include/math.h +++ b/vendor/libc/include/math.h @@ -1,21 +1,66 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + #include +#define INFINITY (1.0 / 0.0) +#define NAN (0.0 / 0.0) + float sqrtf(float); float cosf(float); float sinf(float); float atan2f(float, float); -bool isnan(float); -bool isinf(float); + +float floorf(float x); double floor(double x); +float ceilf(float x); double ceil(double x); double sqrt(double x); +float powf(float x, float y); double pow(double x, double y); +float fmodf(float x, float y); double fmod(double x, double y); double cos(double x); +float acosf(float x); double acos(double x); +float fabsf(float x); double fabs(double x); int abs(int); double ldexp(double, int); double exp(double); +float logf(float); double log(double); double sin(double); +double trunc(double); +double log2(double); +double log10(double); +double asin(double); +double atan(double); +double tan(double); +double atan2(double, double); +double modf(double, double*); + +bool __isnanf(float); +bool __isnand(double); +#define isnan(x) \ + ( sizeof(x) == sizeof(float) ? __isnanf((float)(x)) \ + : : __isnand((double)(x))) + +bool __isinff(float); +bool __isinfd(double); +#define isinf(x) \ + ( sizeof(x) == sizeof(float) ? __isinff((float)(x)) \ + : : __isinfd((double)(x))) + +bool __isfinitef(float); +bool __isfinited(double); +#define isfinite(x) \ + ( sizeof(x) == sizeof(float) ? __isfinitef((float)(x)) \ + : : __isfinited((double)(x))) + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/include/stdio.h b/vendor/libc/include/stdio.h index 807437f3c..06339c1a3 100644 --- a/vendor/libc/include/stdio.h +++ b/vendor/libc/include/stdio.h @@ -1,8 +1,14 @@ -#include -#include +#ifdef __cplusplus +extern "C" { +#endif #pragma once +#include +#include +#include +#include + typedef struct {} FILE; #define SEEK_SET 0 @@ -12,6 +18,8 @@ typedef struct {} FILE; #define stdout ((FILE *)2) #define stderr ((FILE *)3) +#define EOF -1 + FILE *fopen(const char *, char *); int fclose(FILE *); int fseek(FILE *, long, int); @@ -21,6 +29,10 @@ size_t fwrite(const void *, size_t, size_t, FILE *); int vfprintf(FILE *, const char *, va_list); int vsnprintf(char *, size_t, const char *, va_list); +int vsprintf(char *, const char *, va_list); + +int putchar(int ch); +int getchar(); static inline int snprintf(char *buf, size_t size, const char *fmt, ...) { va_list args; @@ -30,6 +42,14 @@ static inline int snprintf(char *buf, size_t size, const char *fmt, ...) { return result; } +static inline int sprintf(char *buf, const char *fmt, ...) { + va_list args; + va_start(args, fmt); + int result = vsprintf(buf, fmt, args); + va_end(args); + return result; +} + static inline int fprintf(FILE *f, const char *fmt, ...) { va_list args; va_start(args, fmt); @@ -45,3 +65,37 @@ static inline int printf(const char *fmt, ...) { va_end(args); return result; } + +int __sscanf(const char *str, const char *format, void *ptrs); + +static inline int vsscanf(const char *str, const char *format, va_list ap) { + int count = 0; + for (int i = 0; format[i]; i++) { + if (format[i] == '%') { + if (format[i+1] == '%') { + i++; + continue; + } + count++; + } + } + + void **ptrs = (void **)(alloca(count*sizeof(void *))); + for (int i = 0; i < count; i++) { + ptrs[i] = va_arg(ap, void *); + } + + return __sscanf(str, format, ptrs); +} + +static inline int sscanf(const char *str, const char *format, ...) { + va_list args; + va_start(args, format); + int res = vsscanf(str, format, args); + va_end(args); + return res; +} + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/include/stdlib.h b/vendor/libc/include/stdlib.h index 22cfc528b..01c6ac6b2 100644 --- a/vendor/libc/include/stdlib.h +++ b/vendor/libc/include/stdlib.h @@ -1,3 +1,9 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + #include void *malloc(size_t size); @@ -17,3 +23,22 @@ long long atoll(const char *); double atof(const char *); long strtol(const char *, char **, int); +double strtod(const char *, char **); + +void abort(); +void exit(int exit_code); + +#define ATEXIT_MAX 32 + +int atexit(typeof(void (void)) *); + +typedef struct { + long int quot; + long int rem; +} ldiv_t; + +ldiv_t ldiv(long int number, long int denom); + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/include/string.h b/vendor/libc/include/string.h index 4571f9454..7e5e2b252 100644 --- a/vendor/libc/include/string.h +++ b/vendor/libc/include/string.h @@ -1,9 +1,16 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + #include void *memcpy(void *, const void *, size_t); void *memset(void *, int, size_t); void *memmove(void *, void *, size_t); int memcmp(const void *, const void *, size_t); +void *memchr(const void *, int, size_t); unsigned long strlen(const char *str); @@ -19,3 +26,7 @@ int strcmp(const char *, const char *); int strncmp(const char *, const char *, size_t); char *strstr(const char *, const char *); + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/include/time.h b/vendor/libc/include/time.h new file mode 100644 index 000000000..369e25256 --- /dev/null +++ b/vendor/libc/include/time.h @@ -0,0 +1,16 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + +#include + +typedef int64_t clock_t; +typedef clock_t time_t; + +clock_t clock(); + +#ifdef __cplusplus +} +#endif diff --git a/vendor/libc/math.odin b/vendor/libc/math.odin index af319ac6d..93df1fea6 100644 --- a/vendor/libc/math.odin +++ b/vendor/libc/math.odin @@ -14,23 +14,28 @@ cosf :: proc "c" (v: f32) -> f32 { return math.cos(v) } -@(require, linkage="strong", link_name="sinf") -sinf :: proc "c" (v: f32) -> f32 { - return math.sin(v) -} - @(require, linkage="strong", link_name="atan2f") atan2f :: proc "c" (v: f32, v2: f32) -> f32 { return math.atan2(v, v2) } -@(require, linkage="strong", link_name="isnan") -isnan :: proc "c" (v: f32) -> bool { +@(require, linkage="strong", link_name="__isnanf") +isnanf :: proc "c" (v: f32) -> bool { return math.is_nan(v) } -@(require, linkage="strong", link_name="isinf") -isinf :: proc "c" (v: f32) -> bool { +@(require, linkage="strong", link_name="__isnand") +isnand :: proc "c" (v: f64) -> bool { + return math.is_nan(v) +} + +@(require, linkage="strong", link_name="__isinff") +isinff :: proc "c" (v: f32) -> bool { + return math.is_inf(v) +} + +@(require, linkage="strong", link_name="__isinfd") +isinfd :: proc "c" (v: f64) -> bool { return math.is_inf(v) } @@ -39,21 +44,41 @@ sqrt :: proc "c" (x: f64) -> f64 { return math.sqrt(x) } +@(require, linkage="strong", link_name="floorf") +floorf :: proc "c" (x: f32) -> f32 { + return math.floor(x) +} + @(require, linkage="strong", link_name="floor") floor :: proc "c" (x: f64) -> f64 { return math.floor(x) } +@(require, linkage="strong", link_name="ceilf") +ceilf :: proc "c" (x: f32) -> f32 { + return math.ceil(x) +} + @(require, linkage="strong", link_name="ceil") ceil :: proc "c" (x: f64) -> f64 { return math.ceil(x) } +@(require, linkage="strong", link_name="powf") +powf :: proc "c" (x, y: f32) -> f32 { + return math.pow(x, y) +} + @(require, linkage="strong", link_name="pow") pow :: proc "c" (x, y: f64) -> f64 { return math.pow(x, y) } +@(require, linkage="strong", link_name="fmodf") +fmodf :: proc "c" (x, y: f32) -> f32 { + return math.mod(x, y) +} + @(require, linkage="strong", link_name="fmod") fmod :: proc "c" (x, y: f64) -> f64 { return math.mod(x, y) @@ -64,11 +89,21 @@ cos :: proc "c" (x: f64) -> f64 { return math.cos(x) } +@(require, linkage="strong", link_name="acosf") +acosf :: proc "c" (x: f32) -> f32 { + return math.acos(x) +} + @(require, linkage="strong", link_name="acos") acos :: proc "c" (x: f64) -> f64 { return math.acos(x) } +@(require, linkage="strong", link_name="fabsf") +fabsf :: proc "c" (x: f32) -> f32 { + return math.abs(x) +} + @(require, linkage="strong", link_name="fabs") fabs :: proc "c" (x: f64) -> f64 { return math.abs(x) @@ -89,6 +124,11 @@ exp :: proc "c" (x: f64) -> f64 { return math.exp(x) } +@(require, linkage="strong", link_name="logf") +logf :: proc "c" (x: f32) -> f32 { + return math.ln(x) +} + @(require, linkage="strong", link_name="log") log :: proc "c" (x: f64) -> f64 { return math.ln(x) @@ -98,3 +138,69 @@ log :: proc "c" (x: f64) -> f64 { sin :: proc "c" (x: f64) -> f64 { return math.sin(x) } + +@(require, linkage="strong", link_name="sinf") +sinf :: proc "c" (v: f32) -> f32 { + return math.sin(v) +} + + +@(require, linkage="strong", link_name="trunc") +trunc :: proc "c" (x: f64) -> f64 { + return math.trunc(x) +} + +@(require, linkage="strong", link_name="__isfinitef") +isfinitef :: proc "c" (x: f32) -> bool { + switch math.classify(x) { + case .Normal, .Subnormal, .Zero, .Neg_Zero: return true + case .Inf, .Neg_Inf, .NaN: return false + case: unreachable() + } +} + +@(require, linkage="strong", link_name="__isfinited") +isfinited :: proc "c" (x: f64) -> bool { + switch math.classify(x) { + case .Normal, .Subnormal, .Zero, .Neg_Zero: return true + case .Inf, .Neg_Inf, .NaN: return false + case: unreachable() + } +} + +@(require, linkage="strong", link_name="log2") +log2 :: proc "c" (x: f64) -> f64 { + return math.log2(x) +} + +@(require, linkage="strong", link_name="log10") +log10 :: proc "c" (x: f64) -> f64 { + return math.log10(x) +} + +@(require, linkage="strong", link_name="asin") +asin :: proc "c" (x: f64) -> f64 { + return math.asin(x) +} + +@(require, linkage="strong", link_name="atan") +atan :: proc "c" (x: f64) -> f64 { + return math.atan(x) +} + +@(require, linkage="strong", link_name="tan") +tan :: proc "c" (x: f64) -> f64 { + return math.tan(x) +} + +@(require, linkage="strong", link_name="atan2") +atan2 :: proc "c" (y: f64, x: f64) -> f64 { + return math.atan2(y, x) +} + +@(require, linkage="strong", link_name="modf") +modf :: proc "c" (num: f64, iptr: ^f64) -> f64 { + integral, fractional := math.modf(num) + iptr^ = integral + return fractional +} diff --git a/vendor/libc/stdio.odin b/vendor/libc/stdio.odin index 97667a5c8..d41f790ee 100644 --- a/vendor/libc/stdio.odin +++ b/vendor/libc/stdio.odin @@ -1,18 +1,23 @@ #+build !freestanding package odin_libc +import "base:runtime" + import "core:c" import "core:io" import "core:os" +import "core:strconv" import stb "vendor:stb/sprintf" FILE :: uintptr +EOF :: -1 + @(require, linkage="strong", link_name="fopen") fopen :: proc "c" (path: cstring, mode: cstring) -> FILE { context = g_ctx - unimplemented("odin_libc.fopen") + unimplemented("vendor/libc: fopen") } @(require, linkage="strong", link_name="fseek") @@ -63,6 +68,31 @@ fwrite :: proc "c" (buffer: [^]byte, size: uint, count: uint, file: FILE) -> uin return uint(max(0, n)) } +@(require, linkage="strong", link_name="putchar") +putchar :: proc "c" (char: c.int) -> c.int { + context = g_ctx + + n, err := os.write_byte(os.stdout, byte(char)) + if n == 0 || err != nil { + return EOF + } + return char +} + +@(require, linkage="strong", link_name="getchar") +getchar :: proc "c" () -> c.int { + when #defined(os.stdin) { + ret: [1]byte + n, err := os.read(os.stdin, ret[:]) + if n == 0 || err != nil { + return EOF + } + return c.int(ret[0]) + } else { + return EOF + } +} + @(require, linkage="strong", link_name="vsnprintf") vsnprintf :: proc "c" (buf: [^]byte, count: uint, fmt: cstring, args: ^c.va_list) -> i32 { i32_count := i32(count) @@ -70,6 +100,11 @@ vsnprintf :: proc "c" (buf: [^]byte, count: uint, fmt: cstring, args: ^c.va_list return stb.vsnprintf(buf, i32_count, fmt, args) } +@(require, linkage="strong", link_name="vsprintf") +vsprintf :: proc "c" (buf: [^]byte, fmt: cstring, args: ^c.va_list) -> i32 { + return stb.vsprintf(buf, fmt, args) +} + @(require, linkage="strong", link_name="vfprintf") vfprintf :: proc "c" (file: FILE, fmt: cstring, args: ^c.va_list) -> i32 { context = g_ctx @@ -105,3 +140,379 @@ vfprintf :: proc "c" (file: FILE, fmt: cstring, args: ^c.va_list) -> i32 { return i32(len(buf)) } + +/* +Derived from musl libc - MIT licensed - Copyright © 2005-2020 Rich Felker, et al. +*/ +@(require, linkage="strong", link_name="__sscanf") +_sscanf :: proc "c" (str, fmt: [^]byte, orig_ptrs: [^]rawptr) -> i32 { + Size :: enum u8 { + None, + hh, + h, + l, + L, + ll, + } + + store_int :: proc(dest: rawptr, size: Size, i: u64) { + if dest == nil { return } + #partial switch size { + case .hh: + (^c.char)(dest)^ = c.char(i) + case .h: + (^c.short)(dest)^ = c.short(i) + case .None: + (^c.int)(dest)^ = c.int(i) + case .l: + (^c.long)(dest)^ = c.long(i) + case .ll: + (^c.longlong)(dest)^ = c.longlong(i) + } + } + + context = g_ctx + + str := str + ptrs := orig_ptrs + + // TODO: implement wide char variants + + pos: u64 + dest: rawptr + ch, t: byte + // wcs: [^]c.wchar_t + s: [^]byte + k, i, width: int + alloc: bool + scanset: [257]byte + invert: u8 + matches: i32 + size: Size + input_fail, match_fail, fmt_fail, alloc_fail: bool + + main_loop: for p := fmt; p[0] != 0; p = p[1:] { + alloc = false + + if isspace(i32(p[0])) { + for isspace(i32(p[0])) { + p = p[1:] + } + for isspace(i32(str[0])) { + str = str[1:] + pos += 1 + } + } + + if p[0] != '%' || p[1] == '%' { + if p[0] == '%' { + p = p[1:] + } + ch = str[0] + if ch != p[0] { + if ch == 0 { + input_fail = true + break + } + match_fail = true + break + } + pos += 1 + continue + } + + p = p[1:] + if p[0] == '*' { + dest = nil + p = p[1:] + } else if isdigit(i32(p[0])) && p[1] == '$' { + dest = orig_ptrs[p[0] - '0'] + p = p[2:] + } else { + dest = ptrs[0] + ptrs = ptrs[1:] + } + + for width = 0; isdigit(i32(p[0])); p = p[1:] { + width = 10 * width + int(p[0] - '0') + } + + if p[0] == 'm' { + // wcs = nil + s = nil + alloc = dest != nil + p = p[1:] + } else { + alloc = false + } + + size = .None + p = p[1:] + switch p[-1] { + case 'h': + size = .h + if p[0] == 'h' { + p = p[1:] + size = .hh + } + case 'l': + size = .l + if p[0] == 'l' { + p = p[1:] + size = .ll + } + case 'j': + size = .ll + case 'z', 't': + size = .l + case 'L': + size = .L + case 'd', 'i', 'o', 'u', 'x', + 'a', 'e', 'f', 'g', + 'A', 'E', 'F', 'G', 'X', + 's', 'c', '[', + 'S', 'C', 'p', 'n': + p = p[-1:] + case: + fmt_fail = true + break main_loop + } + + t = p[0] + + switch t { + case 'C': + t = 'c' + size = .l + case 'S': + t = 's' + size = .l + } + + switch t { + case 'c': + if width < 1 { + width = 1 + } + case '[': + case 'n': + store_int(dest, size, pos) + continue + case: + for isspace(i32(str[0])) { + str = str[1:] + pos += 1 + } + } + + if str[0] == 0 { + input_fail = true + break + } + + if width == 0 { + width = max(int) + } + + switch t { + case 's', 'c', '[': + if t == 'c' || t == 's' { + runtime.memset(&scanset, -1, size_of(scanset)) + scanset[0] = 0 + if t == 's' { + scanset['\t'] = 0 + scanset['\n'] = 0 + scanset['\v'] = 0 + scanset['\f'] = 0 + scanset['\r'] = 0 + scanset[' '] = 0 + } + } else { + p = p[1:] + invert = 0 + if p[0] == '^' { + p = p[1:] + invert = 1 + } + + runtime.memset(&scanset, i32(invert), size_of(scanset)) + scanset[0] = 0 + if p[0] == '-' { + p = p[1:] + scanset['-'] = 1 - invert + } else if p[0] == ']' { + p = p[1:] + scanset[']'] = 1 - invert + } + + for ; p[0] != ']'; p = p[1:] { + if p[0] == 0 { + fmt_fail = true + break main_loop + } + if p[0] == '-' && p[1] != ']' { + c := p + p = p[1:] + for ch = c[0]; c[0] < p[0]; c, ch = c[1:], c[0] { + scanset[ch] = 1 - invert + } + scanset[p[0]] = 1 - invert + } + } + } + + // wcs = nil + s = nil + i = 0 + k = t == 'c' ? width + 1 : 31 + if size == .l { + unimplemented("vendor/libc: sscanf wide character support") + } else if alloc { + s = make([^]byte, k) + if s == nil { + alloc_fail = true + break main_loop + } + + for ch = str[0]; scanset[ch] != 0 && i < width; { + s[i] = ch + i += 1 + if i == k { + old_size := k + k += k + 1 + tmp, _ := runtime.non_zero_mem_resize(s, old_size, k) + if tmp == nil { + alloc_fail = true + break main_loop + } + s = raw_data(tmp) + } + + str = str[1:] + ch = str[0] + } + } else { + s = cast([^]byte)dest + if s != nil { + for ch = str[0]; scanset[ch] != 0 && i < width; { + s[i] = ch + i += 1 + + str = str[1:] + ch = str[0] + } + } else { + for ; scanset[str[0]] != 0 && i < width; str = str[1:] {} + } + } + + if i == 0 { + match_fail = true + break main_loop + } + + str = str[-1:] + + if t == 'c' && i != width { + match_fail = true + break main_loop + } + + if alloc { + (^rawptr)(dest)^ = s + } + + if t != 'c' { + if s != nil {s[i] = 0} + } + case: + base := -1 + switch t { + case 'p', 'X', 'x': + base = 16 + if i + 2 < width && str[0] == '0' && str[1] == 'x' { + str = str[2:] + } + case 'o': + base = 8 + if i + 1 < width && str[0] == '0' { + str = str[1:] + } + case 'd', 'u': + base = 10 + case 'i': + base = 0 + } + + odin_str := string(cstring(str)) + odin_str = odin_str[:min(len(odin_str), width-i)] + cnt: int + if base >= 0 { + x: i64 + if base == 0 { + x, _ = strconv.parse_i64_maybe_prefixed(odin_str, &cnt) + } else { + x, _ = strconv.parse_i64_of_base(odin_str, base, &cnt) + } + + if cnt == 0 { + match_fail = true + break main_loop + } + + if t == 'p' && dest != nil { + (^rawptr)(dest)^ = rawptr(uintptr(x)) + } else { + store_int(dest, size, u64(x)) + } + } else { + // should be a guarantee bcs of validation above. + // switch t { + // case 'a', 'A', + // 'e', 'E', + // 'f', 'F', + // 'g', 'G': + // } + x, _ := strconv.parse_f64(odin_str, &cnt) + + if cnt == 0 { + match_fail = true + break main_loop + } + + if dest != nil { + #partial switch size { + case .None: + (^c.float)(dest)^ = c.float(x) + case .l: + (^c.double)(dest)^ = c.double(x) + case .L: + (^c.double)(dest)^ = c.double(x) // longdouble + } + } + } + + pos += u64(cnt) + str = str[cnt:] + } + + if dest != nil { + matches += 1 + } + } + + if fmt_fail || alloc_fail || input_fail { + if matches == 0 { + matches = -1 + } + } + + if match_fail { + if alloc { + free(s) + // free(wcs) + } + } + + return matches +} diff --git a/vendor/libc/stdlib.odin b/vendor/libc/stdlib.odin index 54590c1c9..9f578a436 100644 --- a/vendor/libc/stdlib.odin +++ b/vendor/libc/stdlib.odin @@ -1,8 +1,10 @@ package odin_libc +import "base:intrinsics" import "base:runtime" import "core:c" +import "core:os" import "core:slice" import "core:sort" import "core:strconv" @@ -108,12 +110,81 @@ atof :: proc "c" (str: cstring) -> f64 { @(require, linkage="strong", link_name="strtol") strtol :: proc "c" (str: cstring, str_end: ^cstring, base: i32) -> c.long { context = g_ctx - sstr := string(str) sstr = strings.trim_left_space(sstr) n: int i, _ := strconv.parse_i64_of_base(sstr, int(base), &n) str_end ^= cstring(raw_data(sstr)[n:]) + if str_end != nil { + str_end ^= cstring(raw_data(sstr)[n:]) + } return c.long(clamp(i, i64(min(c.long)), i64(max(c.long)))) } + +@(require, linkage="strong", link_name="strtod") +strtod :: proc "c" (str: cstring, str_end: ^cstring) -> c.double { + context = g_ctx + + sstr := string(str) + sstr = strings.trim_left_space(sstr) + + n: int + val, _ := strconv.parse_f64(sstr, &n) + if str_end != nil { + str_end ^= cstring(raw_data(sstr)[n:]) + } + + return c.double(val) +} + +@(require, linkage="strong", link_name="abort") +abort :: proc "c" () -> ! { + intrinsics.trap() +} + +ATEXIT_MAX :: 32 + +@(private) +atexit_functions: [ATEXIT_MAX]proc "c" () +@(private) +atexit_functions_count: int + +@(require, linkage="strong", link_name="atexit") +atexit :: proc "c" (function: proc "c" ()) -> i32 { + entry := intrinsics.atomic_add(&atexit_functions_count, 1) + if entry >= ATEXIT_MAX { + return -1 + } + + atexit_functions[entry] = function + return 0 +} + + +@(require, linkage="strong", link_name="exit") +exit :: proc "c" (exit_code: c.int) -> ! { + finish_atexit() + os.exit(int(exit_code)) +} + +@(private, fini) +finish_atexit :: proc "c" () { + n := intrinsics.atomic_exchange(&atexit_functions_count, 0) + for function in atexit_functions[:n] { + function() + } +} + +ldiv_t :: struct { + quot: c.long, + rem: c.long, +} + +@(require, linkage="strong", link_name="ldiv") +ldiv :: proc "c" (number: c.long, denom: c.long) -> ldiv_t { + return { + quot = number / denom, + rem = number %% denom, + } +} diff --git a/vendor/libc/string.odin b/vendor/libc/string.odin index 1ab0803da..b8115ea88 100644 --- a/vendor/libc/string.odin +++ b/vendor/libc/string.odin @@ -5,6 +5,7 @@ import "base:intrinsics" import "core:c" import "core:strings" import "core:mem" +import "core:bytes" // NOTE: already defined by Odin. // void *memcpy(void *, const void *, size_t); @@ -109,3 +110,12 @@ strstr :: proc "c" (str: cstring, substr: cstring) -> cstring { return cstring(([^]byte)(str)[idx:]) } +@(require, linkage="strong", link_name="memchr") +memchr :: proc "c" (str: [^]byte, c: i32, n: uint) -> [^]byte { + idx := bytes.index_byte(str[:n], u8(c)) + if idx < 0 { + return nil + } + + return str[idx:] +} diff --git a/vendor/libc/time.odin b/vendor/libc/time.odin new file mode 100644 index 000000000..6d8b8f611 --- /dev/null +++ b/vendor/libc/time.odin @@ -0,0 +1,10 @@ +package odin_libc + +import "core:time" + +clock_t :: i64 + +@(require, linkage="strong", link_name="clock") +clock :: proc "c" () -> clock_t { + return time.tick_now()._nsec +} diff --git a/vendor/sdl3/sdl3_pixels.odin b/vendor/sdl3/sdl3_pixels.odin index 0bea733f8..a9dec79fb 100644 --- a/vendor/sdl3/sdl3_pixels.odin +++ b/vendor/sdl3/sdl3_pixels.odin @@ -550,7 +550,7 @@ PixelFormatDetails :: struct { @(default_calling_convention="c", link_prefix="SDL_") foreign lib { - GetPixelFormatName :: proc(format: PixelFormat) -> rawptr --- + GetPixelFormatName :: proc(format: PixelFormat) -> cstring --- GetMasksForPixelFormat :: proc(format: PixelFormat, bpp: ^c.int, Rmask, Gmask, Bmask, Amask: ^Uint32) -> bool --- GetPixelFormatForMasks :: proc(bpp: c.int, Rmask, Gmask, Bmask, Amask: Uint32) -> PixelFormat --- GetPixelFormatDetails :: proc(format: PixelFormat) -> ^PixelFormatDetails --- @@ -561,4 +561,4 @@ foreign lib { MapRGBA :: proc(format: ^PixelFormatDetails, palette: ^Palette, r, g, b, a: Uint8) -> Uint32 --- GetRGB :: proc(pixel: Uint32, format: ^PixelFormatDetails, palette: ^Palette, r, g, b: ^Uint8) --- GetRGBA :: proc(pixel: Uint32, format: ^PixelFormatDetails, palette: ^Palette, r, g, b, a: ^Uint8) --- -} \ No newline at end of file +} diff --git a/vendor/wasm/WebGL/webgl.odin b/vendor/wasm/WebGL/webgl.odin index 389e729de..61e0efd58 100644 --- a/vendor/wasm/WebGL/webgl.odin +++ b/vendor/wasm/WebGL/webgl.odin @@ -46,16 +46,17 @@ foreign webgl { IsExtensionSupported :: proc(name: string) -> bool --- - ActiveTexture :: proc(x: Enum) --- - AttachShader :: proc(program: Program, shader: Shader) --- - BindAttribLocation :: proc(program: Program, index: i32, name: string) --- - BindBuffer :: proc(target: Enum, buffer: Buffer) --- - BindFramebuffer :: proc(target: Enum, framebuffer: Framebuffer) --- - BindTexture :: proc(target: Enum, texture: Texture) --- - BlendColor :: proc(red, green, blue, alpha: f32) --- - BlendEquation :: proc(mode: Enum) --- - BlendFunc :: proc(sfactor, dfactor: Enum) --- - BlendFuncSeparate :: proc(srcRGB, dstRGB, srcAlpha, dstAlpha: Enum) --- + ActiveTexture :: proc(x: Enum) --- + AttachShader :: proc(program: Program, shader: Shader) --- + BindAttribLocation :: proc(program: Program, index: i32, name: string) --- + BindBuffer :: proc(target: Enum, buffer: Buffer) --- + BindFramebuffer :: proc(target: Enum, framebuffer: Framebuffer) --- + BindTexture :: proc(target: Enum, texture: Texture) --- + BlendColor :: proc(red, green, blue, alpha: f32) --- + BlendEquation :: proc(mode: Enum) --- + BlendEquationSeparate :: proc(modeRGB: Enum, modeAlpha: Enum) --- + BlendFunc :: proc(sfactor, dfactor: Enum) --- + BlendFuncSeparate :: proc(srcRGB, dstRGB, srcAlpha, dstAlpha: Enum) --- BufferData :: proc(target: Enum, size: int, data: rawptr, usage: Enum) --- BufferSubData :: proc(target: Enum, offset: uintptr, size: int, data: rawptr) --- @@ -113,6 +114,7 @@ foreign webgl { GetVertexAttribOffset :: proc(index: i32, pname: Enum) -> uintptr --- GetProgramParameter :: proc(program: Program, pname: Enum) -> i32 --- GetParameter :: proc(pname: Enum) -> i32 --- + GetParameter4i :: proc(pname: Enum, v0, v1, v2, v4: ^i32) --- Hint :: proc(target: Enum, mode: Enum) --- diff --git a/vendor/wasm/WebGL/webgl_helpers.odin b/vendor/wasm/WebGL/webgl_helpers.odin index 585706fbc..920734e99 100644 --- a/vendor/wasm/WebGL/webgl_helpers.odin +++ b/vendor/wasm/WebGL/webgl_helpers.odin @@ -29,7 +29,7 @@ CreateProgramFromStrings :: proc(vs_sources, fs_sources: []string) -> (program: } program = CreateProgram() - defer if !ok do DeleteProgram(program) + defer if !ok { DeleteProgram(program) } AttachShader(program, vs) AttachShader(program, fs)