@zigc/lib 0.16.0-dev.3070 → 0.16.0-dev.3121

package/std/zig/Parse.zig

@@ -257,7 +257,7 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
     while (true) {
         const doc_comment = try p.eatDocComments();
 
-        switch (p.tokenTag(p.tok_i)) {
+        sw: switch (p.tokenTag(p.tok_i)) {
             .keyword_test => {
                 if (doc_comment) |some| {
                     try p.warnMsg(.{ .tag = .test_doc_comment, .token = some });
@@ -348,17 +348,7 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
                     p.findNextContainerMember();
                 },
             },
-            .keyword_pub => {
-                p.tok_i += 1;
-                const opt_top_level_decl = try p.expectTopLevelDeclRecoverable();
-                if (opt_top_level_decl) |top_level_decl| {
-                    if (field_state == .seen) {
-                        field_state = .{ .end = top_level_decl };
-                    }
-                    try p.scratch.append(p.gpa, top_level_decl);
-                }
-                trailing = p.tokenTag(p.tok_i - 1) == .semicolon;
-            },
+            .keyword_pub,
             .keyword_const,
             .keyword_var,
             .keyword_threadlocal,
@@ -367,7 +357,27 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
             .keyword_inline,
             .keyword_noinline,
             .keyword_fn,
-            => {
+            => |t| {
+                if (t == .keyword_extern) {
+                    switch (p.tokenTag(p.tok_i + 1)) {
+                        .keyword_struct,
+                        .keyword_union,
+                        .keyword_enum,
+                        .keyword_opaque,
+                        => |ct| continue :sw ct,
+                        else => {},
+                    }
+                }
+                if (t == .keyword_inline) {
+                    switch (p.tokenTag(p.tok_i + 1)) {
+                        .keyword_for,
+                        .keyword_while,
+                        => |ct| continue :sw ct,
+                        else => {},
+                    }
+                }
+
+                p.tok_i += @intFromBool(t == .keyword_pub);
                 const opt_top_level_decl = try p.expectTopLevelDeclRecoverable();
                 if (opt_top_level_decl) |top_level_decl| {
                     if (field_state == .seen) {
@@ -588,7 +598,8 @@ fn expectTestDeclRecoverable(p: *Parse) error{OutOfMemory}!?Node.Index {
 }
 
 /// Decl
-///     <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / KEYWORD_inline / KEYWORD_noinline)? FnProto (SEMICOLON / Block)
+///     <- (KEYWORD_export / KEYWORD_inline / KEYWORD_noinline)? FnProto (SEMICOLON / Block)
+///      / KEYWORD_extern STRINGLITERALSINGLE? FnProto SEMICOLON
 ///      / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
 fn expectTopLevelDecl(p: *Parse) !?Node.Index {
     const extern_export_inline_token = p.nextToken();
@@ -665,7 +676,7 @@ fn expectTopLevelDeclRecoverable(p: *Parse) error{OutOfMemory}!?Node.Index {
     };
 }
 
-/// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? AddrSpace? LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr
+/// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? AddrSpace? LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr !ExprSuffix
 fn parseFnProto(p: *Parse) !?Node.Index {
     const fn_token = p.eatToken(.keyword_fn) orelse return null;
 
@@ -853,7 +864,7 @@ fn parseGlobalVarDecl(p: *Parse) !?Node.Index {
     return var_decl;
 }
 
-/// ContainerField <- doc_comment? KEYWORD_comptime? !KEYWORD_fn (IDENTIFIER COLON)? TypeExpr ByteAlign? (EQUAL Expr)?
+/// ContainerField <- doc_comment? (KEYWORD_comptime / !KEYWORD_comptime) !KEYWORD_fn (IDENTIFIER COLON / !(IDENTIFIER COLON))? TypeExpr ByteAlign? (EQUAL Expr)?
 fn expectContainerField(p: *Parse) !Node.Index {
     _ = p.eatToken(.keyword_comptime);
     const main_token = p.tok_i;
@@ -895,16 +906,23 @@ fn expectContainerField(p: *Parse) !Node.Index {
     }
 }
 
-/// Statement
-///     <- KEYWORD_comptime ComptimeStatement
-///      / KEYWORD_nosuspend BlockExprStatement
-///      / KEYWORD_suspend BlockExprStatement
+/// BlockStatement
+///     <- Statement
 ///      / KEYWORD_defer BlockExprStatement
 ///      / KEYWORD_errdefer Payload? BlockExprStatement
-///      / IfStatement
+///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? VarAssignStatement
+///
+/// Statement
+///     <- ExprStatement
+///      / KEYWORD_suspend BlockExprStatement
+///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? AssignExpr SEMICOLON
+///
+/// ExprStatement
+///     <- IfStatement
 ///      / LabeledStatement
-///      / VarDeclExprStatement
-fn expectStatement(p: *Parse, allow_defer_var: bool) Error!Node.Index {
+///      / KEYWORD_nosuspend BlockExprStatement
+///      / KEYWORD_comptime BlockExpr
+fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
     if (p.eatToken(.keyword_comptime)) |comptime_token| {
         const opt_block_expr = try p.parseBlockExpr();
         if (opt_block_expr) |block_expr| {
@@ -915,7 +933,7 @@ fn expectStatement(p: *Parse, allow_defer_var: bool) Error!Node.Index {
             });
         }
 
-        if (allow_defer_var) {
+        if (is_block_level) {
             return p.expectVarDeclExprStatement(comptime_token);
         } else {
             const assign = try p.expectAssignExpr();
@@ -949,12 +967,12 @@ fn expectStatement(p: *Parse, allow_defer_var: bool) Error!Node.Index {
                 .data = .{ .node = block_expr },
             });
         },
-        .keyword_defer => if (allow_defer_var) return p.addNode(.{
+        .keyword_defer => if (is_block_level) return p.addNode(.{
             .tag = .@"defer",
             .main_token = p.nextToken(),
             .data = .{ .node = try p.expectBlockExprStatement() },
         }),
-        .keyword_errdefer => if (allow_defer_var) return p.addNode(.{
+        .keyword_errdefer => if (is_block_level) return p.addNode(.{
             .tag = .@"errdefer",
             .main_token = p.nextToken(),
             .data = .{ .opt_token_and_node = .{
@@ -979,7 +997,7 @@ fn expectStatement(p: *Parse, allow_defer_var: bool) Error!Node.Index {
 
     if (try p.parseLabeledStatement()) |labeled_statement| return labeled_statement;
 
-    if (allow_defer_var) {
+    if (is_block_level) {
         return p.expectVarDeclExprStatement(null);
     } else {
         const assign = try p.expectAssignExpr();
@@ -1007,8 +1025,10 @@ fn expectComptimeStatement(p: *Parse, comptime_token: TokenIndex) !Node.Index {
 }
 
 /// VarDeclExprStatement
-///    <- VarDeclProto (COMMA (VarDeclProto / Expr))* EQUAL Expr SEMICOLON
-///     / Expr (AssignOp Expr / (COMMA (VarDeclProto / Expr))+ EQUAL Expr)? SEMICOLON
+///    <- Expr
+///     / VarAssignStatement
+///
+/// VarAssignStatement <- (VarDeclProto / Expr) (COMMA (VarDeclProto / Expr))* EQUAL Expr SEMICOLON
 fn expectVarDeclExprStatement(p: *Parse, comptime_token: ?TokenIndex) !Node.Index {
     const scratch_top = p.scratch.items.len;
     defer p.scratch.shrinkRetainingCapacity(scratch_top);
@@ -1140,7 +1160,7 @@ fn expectStatementRecoverable(p: *Parse) Error!?Node.Index {
 
 /// IfStatement
 ///     <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-///      / IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
+///      / IfPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
 fn expectIfStatement(p: *Parse) !Node.Index {
     const if_token = p.assertToken(.keyword_if);
     _ = try p.expectToken(.l_paren);
@@ -1235,8 +1255,8 @@ fn parseLoopStatement(p: *Parse) !?Node.Index {
 }
 
 /// ForStatement
-///     <- ForPrefix BlockExpr ( KEYWORD_else Statement )?
-///      / ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement )
+///     <- ForPrefix BlockExpr ( KEYWORD_else Statement / !KEYWORD_else )
+///      / ForPrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Statement )
 fn parseForStatement(p: *Parse) !?Node.Index {
     const for_token = p.eatToken(.keyword_for) orelse return null;
 
@@ -1293,7 +1313,7 @@ fn parseForStatement(p: *Parse) !?Node.Index {
 ///
 /// WhileStatement
 ///     <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
-///      / WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
+///      / WhilePrefix !BlockExpr AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
 fn parseWhileStatement(p: *Parse) !?Node.Index {
     const while_token = p.eatToken(.keyword_while) orelse return null;
     _ = try p.expectToken(.l_paren);
@@ -1383,7 +1403,7 @@ fn parseWhileStatement(p: *Parse) !?Node.Index {
 
 /// BlockExprStatement
 ///     <- BlockExpr
-///      / AssignExpr SEMICOLON
+///      / !BlockExpr AssignExpr SEMICOLON
 fn parseBlockExprStatement(p: *Parse) !?Node.Index {
     const block_expr = try p.parseBlockExpr();
     if (block_expr) |expr| return expr;
@@ -1685,18 +1705,20 @@ fn expectPrefixExpr(p: *Parse) Error!Node.Index {
 /// PrefixTypeOp
 ///     <- QUESTIONMARK
 ///      / KEYWORD_anyframe MINUSRARROW
-///      / SliceTypeStart (ByteAlign / AddrSpace / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
+///      / (ManyPtrTypeStart / SliceTypeStart) KEYWORD_allowzero? ByteAlign? AddrSpace? KEYWORD_const? KEYWORD_volatile?
+///      / SinglePtrTypeStart KEYWORD_allowzero? BitAlign? AddrSpace? KEYWORD_const? KEYWORD_volatile?
 ///      / PtrTypeStart (AddrSpace / KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
 ///      / ArrayTypeStart
 ///
 /// SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
 ///
-/// PtrTypeStart
-///     <- ASTERISK
-///      / ASTERISK2
-///      / LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
+/// SinglePtrTypeStart <- ASTERISK / ASTERISK2
+///
+/// ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
+///
+/// ArrayTypeStart <- LBRACKET Expr !(ASTERISK / ASTERISK2) (COLON Expr)? RBRACKET
 ///
-/// ArrayTypeStart <- LBRACKET Expr (COLON Expr)? RBRACKET
+/// BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
 fn parseTypeExpr(p: *Parse) Error!?Node.Index {
     switch (p.tokenTag(p.tok_i)) {
         .question_mark => return try p.addNode(.{
@@ -1962,12 +1984,12 @@ fn expectTypeExpr(p: *Parse) Error!Node.Index {
 /// PrimaryExpr
 ///     <- AsmExpr
 ///      / IfExpr
-///      / KEYWORD_break BreakLabel? Expr?
-///      / KEYWORD_comptime Expr
-///      / KEYWORD_nosuspend Expr
-///      / KEYWORD_continue BreakLabel? Expr?
-///      / KEYWORD_resume Expr
-///      / KEYWORD_return Expr?
+///      / KEYWORD_break (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
+///      / KEYWORD_comptime Expr !ExprSuffix
+///      / KEYWORD_nosuspend Expr !ExprSuffix
+///      / KEYWORD_continue (BreakLabel / !BreakLabel) (Expr !ExprSuffix / !SinglePtrTypeStart)
+///      / KEYWORD_resume Expr !ExprSuffix
+///      / KEYWORD_return (Expr !ExprSuffix / !SinglePtrTypeStart)
 ///      / BlockLabel? LoopExpr
 ///      / Block
 ///      / CurlySuffixExpr
@@ -2042,10 +2064,6 @@ fn parsePrimaryExpr(p: *Parse) !?Node.Index {
                         p.tok_i += 2;
                         return try p.parseWhileExpr();
                     },
-                    .l_brace => {
-                        p.tok_i += 2;
-                        return try p.parseBlock();
-                    },
                     else => return try p.parseCurlySuffixExpr(),
                 }
             } else {
@@ -2067,12 +2085,12 @@ fn parsePrimaryExpr(p: *Parse) !?Node.Index {
     }
 }
 
-/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
+/// IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffix
 fn parseIfExpr(p: *Parse) !?Node.Index {
     return try p.parseIf(expectExpr);
 }
 
-/// Block <- LBRACE Statement* RBRACE
+/// Block <- LBRACE BlockStatement* RBRACE
 fn parseBlock(p: *Parse) !?Node.Index {
     const lbrace = p.eatToken(.l_brace) orelse return null;
     const scratch_top = p.scratch.items.len;
@@ -2177,7 +2195,7 @@ fn forPrefix(p: *Parse) Error!usize {
 
 /// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
 ///
-/// WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
+/// WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)? !ExprSuffi
 fn parseWhileExpr(p: *Parse) !?Node.Index {
     const while_token = p.eatToken(.keyword_while) orelse return null;
     _ = try p.expectToken(.l_paren);
@@ -2409,10 +2427,10 @@ fn parseSuffixExpr(p: *Parse) !?Node.Index {
 ///      / FnProto
 ///      / GroupedExpr
 ///      / LabeledTypeExpr
-///      / IDENTIFIER
+///      / IDENTIFIER !(COLON LabelableExpr)
 ///      / IfTypeExpr
 ///      / INTEGER
-///      / KEYWORD_comptime TypeExpr
+///      / KEYWORD_comptime TypeExpr !ExprSuffix
 ///      / KEYWORD_error DOT IDENTIFIER
 ///      / KEYWORD_anyframe
 ///      / KEYWORD_unreachable
@@ -2431,7 +2449,7 @@ fn parseSuffixExpr(p: *Parse) !?Node.Index {
 ///
 /// GroupedExpr <- LPAREN Expr RPAREN
 ///
-/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
+/// IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
 ///
 /// LabeledTypeExpr
 ///     <- BlockLabel Block
@@ -2711,7 +2729,7 @@ fn expectPrimaryTypeExpr(p: *Parse) !Node.Index {
 
 /// WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
 ///
-/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
+/// WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? !ExprSuffix
 fn parseWhileTypeExpr(p: *Parse) !?Node.Index {
     const while_token = p.eatToken(.keyword_while) orelse return null;
     _ = try p.expectToken(.l_paren);
@@ -2876,7 +2894,7 @@ fn expectAsmExpr(p: *Parse) !Node.Index {
     });
 }
 
-/// AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
+/// AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
 fn parseAsmOutputItem(p: *Parse) !?Node.Index {
     _ = p.eatToken(.l_bracket) orelse return null;
     const identifier = try p.expectToken(.identifier);
@@ -2902,7 +2920,7 @@ fn parseAsmOutputItem(p: *Parse) !?Node.Index {
     });
 }
 
-/// AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
+/// AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERALSINGLE LPAREN Expr RPAREN
 fn parseAsmInputItem(p: *Parse) !?Node.Index {
     _ = p.eatToken(.l_bracket) orelse return null;
     const identifier = try p.expectToken(.identifier);
@@ -2923,9 +2941,7 @@ fn parseAsmInputItem(p: *Parse) !?Node.Index {
 
 /// BreakLabel <- COLON IDENTIFIER
 fn parseBreakLabel(p: *Parse) Error!OptionalTokenIndex {
-    _ = p.eatToken(.colon) orelse return .none;
-    const next_token = try p.expectToken(.identifier);
-    return .fromToken(next_token);
+    return if (p.eatTokens(&.{ .colon, .identifier })) |i| .fromToken(i + 1) else .none;
 }
 
 /// BlockLabel <- IDENTIFIER COLON
@@ -2950,12 +2966,7 @@ fn expectFieldInit(p: *Parse) !Node.Index {
 
 /// WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
 fn parseWhileContinueExpr(p: *Parse) !?Node.Index {
-    _ = p.eatToken(.colon) orelse {
-        if (p.tokenTag(p.tok_i) == .l_paren and
-            p.tokensOnSameLine(p.tok_i - 1, p.tok_i))
-            return p.fail(.expected_continue_expr);
-        return null;
-    };
+    _ = p.eatToken(.colon) orelse return null;
     _ = try p.expectToken(.l_paren);
     const node = try p.parseAssignExpr() orelse return p.fail(.expected_expr_or_assignment);
     _ = try p.expectToken(.r_paren);
@@ -2993,9 +3004,7 @@ fn parseAddrSpace(p: *Parse) !?Node.Index {
 /// such as in the case of anytype and `...`. Caller must look for rparen to find
 /// out when there are no more param decls left.
 ///
-/// ParamDecl
-///     <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
-///      / DOT3
+/// ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime / !KEYWORD_comptime) (IDENTIFIER COLON / !(IDENTIFIER_COLON)) ParamType
 ///
 /// ParamType
 ///     <- KEYWORD_anytype
@@ -3482,7 +3491,7 @@ fn parseSwitchProngList(p: *Parse) !Node.SubRange {
     return p.listToSpan(p.scratch.items[scratch_top..]);
 }
 
-/// ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
+/// ParamDeclList <- (ParamDecl COMMA)* (ParamDecl / DOT3 COMMA?)?
 fn parseParamDeclList(p: *Parse) !SmallSpan {
     _ = try p.expectToken(.l_paren);
     const scratch_top = p.scratch.items.len;
@@ -3604,9 +3613,9 @@ fn parseIf(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !?N
     });
 }
 
-/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
+/// ForExpr <- ForPrefix Expr (KEYWORD_else Expr / !KEYWORD_else) !ExprSuffix
 ///
-/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
+/// ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr / !KEYWORD_else) !ExprSuffix
 fn parseFor(p: *Parse, comptime bodyParseFn: fn (p: *Parse) Error!Node.Index) !?Node.Index {
     const for_token = p.eatToken(.keyword_for) orelse return null;
 

package/std/zig/system.zig

@@ -423,6 +423,7 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target {
         error.ConnectionResetByPeer => return error.Unexpected,
         error.NotOpenForReading => return error.Unexpected,
         error.SocketUnconnected => return error.Unexpected,
+        error.ReadOnlyFileSystem => return error.Unexpected,
 
         error.AccessDenied,
         error.SymLinkLoop,
@@ -853,6 +854,7 @@ fn glibcVerFromRPath(io: Io, rpath: []const u8) !std.SemanticVersion {
         error.PathAlreadyExists => return error.Unexpected, // read-only
         error.DeviceBusy => return error.Unexpected, // read-only
         error.FileBusy => return error.Unexpected, // read-only
+        error.ReadOnlyFileSystem => return error.Unexpected, // read-only
         error.NoDevice => return error.Unexpected, // not asking for a special device
         error.FileTooBig => return error.Unexpected,
         error.WouldBlock => return error.Unexpected, // not opened in non-blocking

package/std/zig/tokenizer.zig

@@ -313,7 +313,8 @@ pub const Token = struct {
             return tag.lexeme() orelse switch (tag) {
                 .invalid => "invalid token",
                 .identifier => "an identifier",
-                .string_literal, .multiline_string_literal_line => "a string literal",
+                .string_literal => "a string literal",
+                .multiline_string_literal_line => "a multiline string literal",
                 .char_literal => "a character literal",
                 .eof => "EOF",
                 .builtin => "a builtin function",

package/std/zig.zig

@@ -23,6 +23,7 @@ pub const primitives = @import("zig/primitives.zig");
 pub const isPrimitive = primitives.isPrimitive;
 pub const Ast = @import("zig/Ast.zig");
 pub const AstGen = @import("zig/AstGen.zig");
+pub const AstSmith = @import("zig/AstSmith.zig");
 pub const Zir = @import("zig/Zir.zig");
 pub const Zoir = @import("zig/Zoir.zig");
 pub const ZonGen = @import("zig/ZonGen.zig");
@@ -1166,6 +1167,7 @@ pub const ClangCliParam = struct {
 test {
     _ = Ast;
     _ = AstRlAnnotate;
+    _ = AstSmith;
     _ = BuiltinFn;
     _ = Client;
     _ = ErrorBundle;

package/libc/mingw/math/arm/sincos.S

@@ -1,30 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <_mingw_mac.h>
-
-	.file	"sincos.S"
-	.text
-	.align 2
-	/* zig patch: remove sincos symbol because sincos in compiler_rt is used instead */
-	.globl __MINGW_USYMBOL(sincosl)
-	.def	__MINGW_USYMBOL(sincosl);	.scl	2;	.type	32;	.endef
-__MINGW_USYMBOL(sincosl):
-	push {r4, r5, r11, lr}
-	add r11, sp, #8
-	vpush {d8}
-
-	mov r4, r0
-	mov r5, r1
-	vmov.f64 d8, d0
-	bl sin
-	vstr d0, [r4]
-
-	vmov.f64 d0, d8
-	bl cos
-	vstr d0, [r5]
-
-	vpop {d8}
-	pop {r4, r5, r11, pc}

package/libc/mingw/math/arm-common/sincosl.c

@@ -1,13 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-
-#include <math.h>
-
-void sincosl(long double x, long double *s, long double *c)
-{
-    *s = sinl(x);
-    *c = cosl(x);
-}

package/libc/mingw/math/arm64/rint.c

@@ -1,12 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <math.h>
-
-double rint (double x) {
-  double retval = 0.0;
-  __asm__ __volatile__ ("frintx %d0, %d1\n\t" : "=w" (retval) : "w" (x));
-  return retval;
-}

package/libc/mingw/math/arm64/rintf.c

@@ -1,12 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <math.h>
-
-float rintf (float x) {
-  float retval = 0.0F;
-  __asm__ __volatile__ ("frintx %s0, %s1\n\t" : "=w" (retval) : "w" (x));
-  return retval;
-}

package/libc/mingw/math/arm64/sincos.S

@@ -1,32 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <_mingw_mac.h>
-
-	.file	"sincos.S"
-	.text
-	.align 2
-	/* zig patch: remove sincos symbol because sincos in compiler_rt is used instead */
-	.globl __MINGW_USYMBOL(sincosl)
-	.def	__MINGW_USYMBOL(sincosl);	.scl	2;	.type	32;	.endef
-__MINGW_USYMBOL(sincosl):
-	str d8, [sp, #-32]!
-	str x30, [sp, #8]
-	stp x19, x20, [sp, #16]
-
-	mov x19, x0
-	mov x20, x1
-	fmov d8, d0
-	bl sin
-	str d0, [x19]
-
-	fmov d0, d8
-	bl cos
-	str d0, [x20]
-
-	ldp x19, x20, [sp, #16]
-	ldr x30, [sp, #8]
-	ldr d8, [sp], #32
-	ret

package/libc/mingw/math/frexpf.c

@@ -1,13 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-extern double __cdecl frexp(double _X,int *_Y);
-
-float frexpf (float, int *);
-float frexpf (float x, int *expn)
-{
-  return (float)frexp(x, expn);
-}
-

package/libc/mingw/math/frexpl.c

@@ -1,71 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-long double frexpl(long double value, int* exp);
-
-#if __SIZEOF_LONG_DOUBLE__ == __SIZEOF_DOUBLE__
-
-double frexp(double value, int* exp);
-
-/* On ARM `long double` is 64 bits. */
-long double frexpl(long double value, int* exp)
-{
-  return frexp(value, exp);
-}
-
-#elif defined(_AMD64_) || defined(__x86_64__) || defined(_X86_) || defined(__i386__)
-
-#include <stdint.h>
-
-/* https://en.wikipedia.org/wiki/Extended_precision#x86_extended_precision_format */
-typedef union x87reg_ {
-  struct __attribute__((__packed__)) {
-    uint64_t f64;
-    uint16_t exp : 15;
-    uint16_t sgn :  1;
-  };
-  long double f;
-} x87reg;
-
-long double frexpl(long double value, int* exp)
-{
-  int n;
-  x87reg reg;
-  reg.f = value;
-  if(reg.exp == 0x7FFF) {
-    /* The value is an infinity or NaN.
-     * Store zero in `*exp`. Return the value as is. */
-    *exp = 0;
-    return reg.f;
-  }
-  if(reg.exp != 0) {
-    /* The value is normalized.
-     * Extract and zero out the exponent. */
-    *exp = reg.exp - 0x3FFE;
-    reg.exp = 0x3FFE;
-    return reg.f;
-  }
-  if(reg.f64 == 0) {
-    /* The value is zero.
-     * Store zero in `*exp`. Return the value as is.
-     * Note the signness. */
-    *exp = 0;
-    return reg.f;
-  }
-  /* The value is denormalized.
-   * Extract the exponent, normalize the value, then zero out
-   * the exponent. Note that x87 uses an explicit leading bit. */
-  n = __builtin_clzll(reg.f64);
-  reg.f64 <<= n;
-  *exp = 1 - 0x3FFE - n;
-  reg.exp = 0x3FFE;
-  return reg.f;
-}
-
-#else
-
-#error Please add `frexpl()` implementation for this platform.
-
-#endif