Nixyri/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-12-16 16:20:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
31,308 Commits 28 Branches 19 Tags 490 MiB
bae3dbffdf
Commit Graph

31308 Commits

This Branch
This Branch
All Branches
Author SHA1 Message Date
Andrew Kelley
f2c8940aa6 reintroduce the std.builtin safety panic helpers 
motivated by performance
 2024-09-26 12:35:14 -07:00
Andrew Kelley
76f0b6e7d8 delete the old panic stuff again 
now that we have a zig1.wasm update it's not needed
 2024-09-26 12:35:14 -07:00
Andrew Kelley
9ccf8d3332 fixes for this branch 
I had to bring back some of the old API so that I could compile the new
compiler with an old compiler.
 2024-09-26 12:35:14 -07:00
Andrew Kelley
4f8d244e7e remove formatted panics 
implements #17969
 2024-09-26 12:35:14 -07:00
Andrew Kelley
04e694ad11 move std.time.sleep to std.Thread.sleep 2024-09-26 12:35:14 -07:00
Alex Rønne Petersen
2db3c77060
std.io.Reader: Fix test erroneously using undefined. 2024-09-26 17:04:36 +02:00
dave caruso
085cc54aad replace TranslateC.addIncludeDir with variants with LazyPath/library names 2024-09-25 21:50:55 -07:00
pseudoc
0d00c733de std.os.linux: extend rtattr.type to support IFA_* 
This is a breaking change which updates the `rtattr.type` from `IFLA` to
`union { IFLA, IFA }`. `IFLA` is for the `RTM_*LINK` messages and `IFA`
is for the `RTM_*ADDR` messages.
 2024-09-26 10:54:18 +08:00
Andrew Kelley
0e876a6378
Merge pull request #21514 from ziglang/elf-incr 
elf: get incremental tests passing via `incr-check` tool
 2024-09-25 19:41:13 -07:00
Andrew Kelley
4442288656 std: fix inappropriate use of unreachable in fanotify_init 2024-09-25 16:07:04 -07:00
mlugg
054dbb6798
incr-check: specify backend in manifest, allow multiple targets/backends 2024-09-25 20:39:31 +01:00
Jakub Konka
1714b74edf incr-check: actually handle end message for a compiler update 2024-09-25 17:54:50 +02:00
Jakub Konka
1c2048ebcc incr-check: add --debug-link flag for verbose linker logging 2024-09-25 17:54:50 +02:00
Jakub Konka
50074a835a elf: remove unused code 2024-09-25 17:54:50 +02:00
Jakub Konka
10c68d05db elf: change how we create new program headers 
We do not want to create additional ones per update that are duplicates
of existing ones.
 2024-09-25 17:54:50 +02:00
Jakub Konka
992c6c3f68 elf: reset output symtab contexts before re-updating 2024-09-25 17:54:50 +02:00
Jakub Konka
82cf762b02 elf: reset (merge) sections sizes before updating 2024-09-25 17:54:50 +02:00
Jakub Konka
db3db1150e elf: do not re-create special program headers if already created 2024-09-25 17:54:50 +02:00
Jakub Konka
62c282ba46 elf: do not re-create synthetic sections if already created 2024-09-25 17:54:50 +02:00
Maciej 'vesim' Kuliński
4ceefca14b mips: use byval for all integer types 2024-09-25 07:37:03 -07:00
Andrew Kelley
efc98fcbeb disallow non-scalar sentinel types 
see #17969
 2024-09-25 03:02:05 -07:00
Alex Rønne Petersen
a40cdad18c tsan: Update to LLVM 19.1.0. 2024-09-24 23:58:21 -07:00
matt
7f6b7c5608 fix THREAD_STATE_NONE on darwin 
#21094
 2024-09-24 22:41:00 -07:00
Krzysztof Wolicki
4d09fb491f
fetch: fix mutating unrelated fields when saving (#19816) 
closes #19725
 2024-09-24 13:38:13 -07:00
Meghan Denny
5e4da1ff30
std: add arch bits for s390x-linux (#21342) 
see #21402
 2024-09-24 13:35:12 -07:00
Nameless
8d76c02f9a uefi: erroneous alignment check in pool_allocator 
Fixes #21446

Both UefiPoolAllocator and UefiRawPoolAllocator were
passing the value of `log2_ptr_align` directly to
`mem.alignAllocLen` which expects a alignment value.

Both of these calls to `mem.alignAllocLen` are pointless
and the result of the alignment both always true, and
was thrown away anyway.

I have removed these calls entirely.
 2024-09-24 13:30:53 -07:00
WillLillis
37cd21eb5f fix: disallow discard as errdefer capture 2024-09-24 13:21:06 -07:00
Alex Kladov
ffd071f558 fix IB in fifoToOwnedArrayList 
memcpy requires non-overlapping arguments.

fifo.realign() handles this case correctly and tries to provide an
optimized implementation.

This probably wasn't hit in practice, as, in a typical usage, fifo's
head is not advanced.
 2024-09-24 13:19:06 -07:00
Frank Denis
c062c532d7 Add post-quantum key agreement X25519MLKEM768 
X25519MLKEM768 replaces X25519Kyber768Draft00 now that NIST has
released ML-KEM.

IANA has assigned the codepoint 0x11ec:
https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8
 2024-09-24 13:18:32 -07:00
Alex Rønne Petersen
5458c9c71b
std.Target: Regenerate CPU models/features based on LLVM 19.1.0. 
* DefaultExts parsing for aarch64.
* cortex-m85 trustzone correction for arm.
 2024-09-24 11:45:01 +02:00
Alex Rønne Petersen
c0561da179
update_cpu_features: Don't set trustzone on cortex-m85. 
cortex-m85 already has 8msecext, which is not the same as trustzone. The former
is for the M profile, while the latter is for the A profile.

Revert of a small part of #18498.
 2024-09-24 11:45:01 +02:00
Alex Rønne Petersen
dcbd3cbce9
update_cpu_features: Add support for parsing DefaultExts as used for aarch64. 2024-09-24 11:08:29 +02:00
Alex Rønne Petersen
ebbc50d8be
std.Target: Introduce Abi.androideabi to distinguish the soft float case. 
Abi.android on its own is not enough to know whether soft float or hard float
should be used. In the C world, androideabi is typically used for the soft float
case, so let's go with that.

Note that Android doesn't have a hard float ABI, so no androideabihf.

Closes #21488.
 2024-09-24 09:23:24 +02:00
Alex Rønne Petersen
d3ba5f397d compiler-rt: Export extra soft float libcall names for thumb-windows-gnu. 2024-09-23 21:20:00 -07:00
Alex Rønne Petersen
5daf47a212 zig.h: Improve portability of zig_trap() and zig_breakpoint(). 2024-09-23 17:34:15 -07:00
Alex Rønne Petersen
c1cc63e5ff libc: Work around LLVM's misassembly of j <reg> on mips r6. 
See: https://github.com/ziglang/zig/issues/21315
 2024-09-23 17:26:30 -07:00
Lucas Santos
b19d0fb0fd
Improve efficiency of buffered_reader. (#21256) 
The previous implementation of buffered_reader always reads from the
unbuffered reader into the internal buffer, and then dumps the data onto
the destination. This is inefficient, as sometimes it's possible to read
directly into the destination. The previous strategy generates more
memory copies and unbuffered reads than necessary.
 2024-09-23 17:20:27 -07:00
Alex Rønne Petersen
d1901c744c std.Target: Remove Cpu.Arch.dxil and ObjectFormat.dxcontainer. 
See: https://devblogs.microsoft.com/directx/directx-adopting-spir-v

Since we never hooked up the (experimental) DirectX LLVM backend, we've never
actually supported targeting DXIL in Zig. With Microsoft moving away from DXIL,
that seems very unlikely to change.
 2024-09-23 17:17:25 -07:00
Fri3dNstuff
b2c53eb0d7
std.math: change gcd's implementation to use Stein's algorithm instead of Euclid's (#21077) 2024-09-23 17:15:57 -07:00
Andrew Kelley
a08f8d44da
Merge pull request #21472 from alexrp/libunwind 
`libunwind`: Update `gcc_personality_v0.c` to LLVM 19.1.0.
 2024-09-23 13:19:14 -07:00
Igor Stojković
0676c04681
tokenizer: fix 0 byte following invalid (#21482) 
closes #21481
 2024-09-23 13:06:30 -07:00
Will Lillis
943176bbfc
fix: Add error note when attempt is made to destructure error union (#21491) 
closes #21417
 2024-09-23 13:04:24 -07:00
Lucas Santos
509639717a std.equalRange: Compute lower and upper bounds simultaneously 
The current implementation of `equalRange` just calls `lowerRange` and `upperRange`, but a lot of
the work done by these two functions can be shared. Specifically, each iteration gives information about whether the lower bound or the upper bound can be tightened. This leads to fewer iterations and, since there is one comparison per iteration, fewer comparisons.
Implementation adapted from [GCC](519ec1cfe9/libstdc%2B%2B-v3/include/bits/stl_algo.h (L2063)).
This sample demonstrates the difference between the current implementation and mine:

```zig
fn S(comptime T: type) type {
    return struct {
        needle: T,
        count: *usize,

        pub fn order(context: @This(), item: T) std.math.Order {
            context.count.* += 1;
            return std.math.order(item, context.needle);
        }
        pub fn orderLength(context: @This(), item: []const u8) std.math.Order {
            context.count.* += 1;
            return std.math.order(item.len, context.needle);
        }
    };
}
pub fn main() !void {
    var count: usize = 0;

    try std.testing.expectEqual(.{ 0, 0 }, equalRange(i32, &[_]i32{}, S(i32){ .needle = 0, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 0, 0 }, equalRange(i32, &[_]i32{ 2, 4, 8, 16, 32, 64 }, S(i32){ .needle = 0, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 0, 1 }, equalRange(i32, &[_]i32{ 2, 4, 8, 16, 32, 64 }, S(i32){ .needle = 2, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 2, 2 }, equalRange(i32, &[_]i32{ 2, 4, 8, 16, 32, 64 }, S(i32){ .needle = 5, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 2, 3 }, equalRange(i32, &[_]i32{ 2, 4, 8, 16, 32, 64 }, S(i32){ .needle = 8, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 5, 6 }, equalRange(i32, &[_]i32{ 2, 4, 8, 16, 32, 64 }, S(i32){ .needle = 64, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 6, 6 }, equalRange(i32, &[_]i32{ 2, 4, 8, 16, 32, 64 }, S(i32){ .needle = 100, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 2, 6 }, equalRange(i32, &[_]i32{ 2, 4, 8, 8, 8, 8, 15, 22 }, S(i32){ .needle = 8, .count = &count }, S(i32).order));
    try std.testing.expectEqual(.{ 2, 2 }, equalRange(u32, &[_]u32{ 2, 4, 8, 16, 32, 64 }, S(u32){ .needle = 5, .count = &count }, S(u32).order));
    try std.testing.expectEqual(.{ 1, 1 }, equalRange(f32, &[_]f32{ -54.2, -26.7, 0.0, 56.55, 100.1, 322.0 }, S(f32){ .needle = -33.4, .count = &count }, S(f32).order));
    try std.testing.expectEqual(.{ 3, 5 }, equalRange(
        []const u8,
        &[_][]const u8{ "Mars", "Venus", "Earth", "Saturn", "Uranus", "Mercury", "Jupiter", "Neptune" },
        S(usize){ .needle = 6, .count = &count },
        S(usize).orderLength,
    ));

    std.debug.print("Count: {}\n", .{count});
}
```
For each comparison, we bump the count. With the current implementation, we get 57 comparisons. With mine, we get 43.

With contributions from @Olvilock.
This is my second attempt at this, since I messed up the [first one](https://github.com/ziglang/zig/pull/21290).
 2024-09-23 13:03:06 -07:00
Jakub Konka
8c232922bd
Merge pull request #21493 from ziglang/elf-fixes 
elf: misc fixes
 2024-09-23 10:58:02 +02:00
Jakub Konka
e0acf43248 elf: always override existing __start/__stop symbols 2024-09-23 07:06:47 +02:00
Jakub Konka
7c2abff1e1 elf: only allocate __dso_handle symbol if not found in any object 2024-09-23 07:06:41 +02:00
Jakub Konka
6929a5f440 elf: remove dead code 2024-09-23 06:59:03 +02:00
Jakub Konka
f4c4ca4b4c elf: fix condition for skipping symbols if atom is dead 
Skipping the symbols too early when resolving would end up in the
linker not deduping CIEs fully.
 2024-09-23 06:56:36 +02:00
Alex Rønne Petersen
a9d1c6acb2
libunwind: Use -Wno-dll-attribute-on-redeclaration for Windows like upstream. 
This silences a bunch of noisy warnings when building libunwind.
 2024-09-21 01:20:36 +02:00
Alex Rønne Petersen
9bc2185997
libunwind: Update gcc_personality_v0.c to LLVM 19.1.0. 
Notably, this fixes libunwind compilation for thumb-windows-gnu.
 2024-09-21 01:16:47 +02:00